/**
 * Copyright (c) 2019, Freqchip
 * 
 * All rights reserved.
 * 
 * 
 */

/*
 * INCLUDES
 */
#include <stdint.h>

#include "os_task.h"
#include "os_msg_q.h"
#include "os_mem.h"

#include "co_printf.h"
#include "user_task.h"
#include "button.h"
#include "driver_gpio.h"
#include "lcd.h"
#include "adpcm_ms.h"
#include "speaker.h"
#include "decoder.h"
#include "ble_simple_peripheral.h"
#include "mic_app.h"
#include "audio_encoder.h"
#include "y_ringbuf.h"
#include "driver_flash.h"
#include "flash_usage_config.h"
/*
 * MACROS 
 */
os_timer_t key_send_timer;
os_timer_t data_consume_timer;  // 新增数据消耗定时器

// 按键状态管理
 uint32_t last_pressed_key = 0;  // 记录上次按下的按键
 bool connection_initialized = false;  // 记录是否已经初始化连接
 bool reset_x_y = false;

void key_send_timer_timeout_handler(void *p);

void  reset_init_poszation(bool start_timer);

// 新增数据消耗定时器处理函数声明
void data_consume_timer_timeout_handler(void *p);

// 新增按键发送任务函数声明
static int key_send_task_func(os_event_t *param);

void add_finger_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len);


void add_double_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len);

void add_scroll_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len);

void fill_digitizer_report_manual(uint16_t x, uint16_t y,
	uint8_t tip_switch, uint8_t in_range,
	uint8_t barrel_switch, uint8_t eraser,
	uint8_t* output_buffer);

// 数据包类型定义
typedef enum {
    DATA_TYPE_MOUSE_REPORT = 0x01,    // 鼠标报告
    DATA_TYPE_HI_RES_REPORT = 0x02,   // 高精度报告

	DATA_TYPE_FINGGER_REPORT = 0x03,   // fingter报告

	DATA_TYPE_DOUBLE_CLICK_REPORT = 0x04,   // fingter报告


	DATA_TYPE_SCROLL_REPORT = 0x05,   // fingter报告
} data_type_t;

// 数据包结构体
typedef struct {
    data_type_t type;     // 数据类型
    uint8_t report_id;    // 报告ID
    uint8_t data[8];      // 数据内容
    uint8_t data_len;     // 数据长度
} data_packet_t;

// RingBuffer相关 - 使用 y_ringbuf
#define MAX_DATA_PACKETS 50  // 最大数据包数量
#define DATA_PACKET_SIZE sizeof(data_packet_t)  // 数据包大小
static RINGBUF_st *data_ringbuf = NULL;  // y_ringbuf 实例
void add_hi_res_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len);
void add_mouse_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len);

/*
 * CONSTANTS 
 */
 // HID Touch 封装函数
typedef enum {
    TOUCH_RELEASE = 0,
    TOUCH_DOWN = 1
} touch_state_t;

void hid_touch_send(uint16_t x, uint16_t y, uint8_t down);


uint16_t delay_connect_send = 10;

// 你的手机屏幕物理尺寸
#define PHYSICAL_MAX_X 1220
#define PHYSICAL_MAX_Y 2712
// HID描述符中定义的逻辑最大值
#define LOGICAL_MAX 4095

#include <stdint.h> // 用于使用标准整数类型如 uint8_t, uint16_t

// 定义状态字节的位域（Bit-field），方便按位操作
typedef union {
    uint8_t byte_value; // 整个状态字节的值
    struct {
        uint8_t tip_switch    : 1; // bit 0
        uint8_t in_range      : 1; // bit 1
        uint8_t padding1      : 1; // bit 2 (通常为常量/填充)
        uint8_t padding2      : 1; // bit 3 (通常为常量/填充)
        uint8_t padding3      : 1; // bit 4 (通常为常量/填充)
        uint8_t barrel_switch : 1; // bit 5 (推测为笔杆侧键)
        uint8_t eraser        : 1; // bit 6 (推测为橡皮擦模式)
        uint8_t padding4      : 1; // bit 7 (通常为常量/填充)
    } bits;
} digitizer_status_t;

// 定义整个Report ID 6的数据包结构
// 注意：这个结构体定义了数据负载，不包括开头的Report ID
typedef struct {
    digitizer_status_t status; // 状态字节
    uint16_t x;                // X坐标
    uint16_t y;                // Y坐标
} digitizer_report_t;

// 或者，如果你需要包含Report ID，可以这样定义：
typedef struct {
    uint8_t report_id;         // 固定为 0x06
    digitizer_status_t status; // 状态字节
    uint16_t x;                // X坐标
    uint16_t y;                // Y坐标
} digitizer_report_full_t;




/**
 * @brief 将物理像素坐标转换为HID逻辑坐标
 * @param phys_x 物理X坐标 (0 - 1220)
 * @param phys_y 物理Y坐标 (0 - 2712)
 * @param hid_x 输出参数：计算出的HID X坐标 (0 - 4095)
 * @param hid_y 输出参数：计算出的HID Y坐标 (0 - 4095)
 */
void convert_to_hid_coord(uint16_t phys_x, uint16_t phys_y, uint16_t *hid_x, uint16_t *hid_y) {
    // 使用32位运算防止溢出
    *hid_x = (uint32_t)phys_x * LOGICAL_MAX / PHYSICAL_MAX_X;
    *hid_y = (uint32_t)phys_y * LOGICAL_MAX / PHYSICAL_MAX_Y;
}








devices_config_t devices_config =  {0};

// 设备配置管理相关全局变量
 uint8_t current_device_index = 0;  // 当前连接的设备索引
static char current_device_name[48] = {0};  // 当前连接的设备名称
static bool devices_config_initialized = false;  // 设备配置是否已初始化







bool report_mode = false;

bool reset_source_posization = false;

bool ios_devices  = false;
bool func_mode = true;

// 鼠标按钮的位掩码定义（符合HID标准）
#define MOUSE_BUTTON_LEFT      (1 << 0)  // 左键
#define MOUSE_BUTTON_RIGHT     (1 << 1)  // 右键
#define MOUSE_BUTTON_MIDDLE    (1 << 2)  // 中键
#define MOUSE_BUTTON_KEY_UP    (1 << 3)  // 后退键
#define MOUSE_BUTTON_KEY_DOWN  (1 << 4)  // 前进键
#define MOUSE_BUTTON_KEY_LEFT  (1 << 5)  // 后退键
#define MOUSE_BUTTON_KEY_RIGHT (1 << 6)  // 前进键
#define MOUSE_BUTTON_KEY_PICTURE (1 << 7)  // 前进键




// 安卓的按钮的位掩码定义（符合HID标准）
#define KEY_BUTTON_VOL_UP      (1 << 0)  //	Vol+ 
#define KEY_BUTTON_VOL_DOWN    (1 << 1)  // Vol-	
#define KEY_BUTTON_VOL_POWER   (1 << 2)  // Power
#define KEY_BUTTON_VOL_MENU    (1 << 3)  // Menu	
#define KEY_BUTTON_VOL_HOME    (1 << 4)  // Home


#define KEY_BUTTON_Previous     (1 << 5)  // Power
#define KEY_BUTTON_Next         (1 << 6)  // Menu	
#define KEY_BUTTON_Play_Pause   (1 << 7)  // Home





//ios 音乐控制
// ===== 报告ID 3 的按键位掩码定义 (24-bit Bitmap) =====
// 数据格式: 3个字节 (Byte0, Byte1, Byte2)，低位在前
// 每个位对应一个按键，1表示按下，0表示释放

// --- 第一个字节 (Byte 0) 的位定义：Bit 0 - 7 ---
#define IOS_KEY_BUTTON_0x70        (1UL << 0)   // 自定义功能 (0x70)
#define IOS_KEY_BUTTON_0x6F        (1UL << 1)   // 自定义功能 (0x6F) 
#define IOS_KEY_BUTTON_SEARCH      (1UL << 2)   // AC Search (搜索)
#define IOS_KEY_BUTTON_CALCULATOR  (1UL << 3)   // AL Calculator (计算器)
#define IOS_KEY_BUTTON_0x0306      (1UL << 4)   // 自定义功能 (0x0306)
#define IOS_KEY_BUTTON_0x0307      (1UL << 5)   // 自定义功能 (0x0307)
#define IOS_KEY_BUTTON_PREV_TRACK  (1UL << 6)   // Scan Previous Track (上一曲)
#define IOS_KEY_BUTTON_PLAY_PAUSE  (1UL << 7)   // Play/Pause (播放/暂停)

// --- IOS_第二个字节 (Byte 1) 的位定义：Bit 8 - 15 ---
#define IOS_KEY_BUTTON_NEXT_TRACK  (1UL << 8)   // Scan Next Track (下一曲)
#define IOS_KEY_BUTTON_MUTE        (1UL << 9)   // Mute (静音)
#define IOS_KEY_BUTTON_VOL_DOWN    (1UL << 10)  // Volume Decrement (音量-)
#define IOS_KEY_BUTTON_VOL_UP      (1UL << 11)  // Volume Increment (音量+)
#define IOS_KEY_BUTTON_BACK        (1UL << 12)  // AC Back (返回)
#define IOS_KEY_BUTTON_EMAIL       (1UL << 13)  // AL Email Reader (电子邮件)
#define IOS_KEY_BUTTON_KBD_LAYOUT  (1UL << 14)  // AL Keyboard Layout (键盘布局)
#define IOS_KEY_BUTTON_HOME        (1UL << 15)  // AC Home (主页)

// --- IOS_第三个字节 (Byte 2) 的位定义：Bit 16 - 23 ---
#define IOS_KEY_BUTTON_BROWSER     (1UL << 16)  // AL Internet Browser (浏览器)
#define IOS_KEY_BUTTON_CALCULATOR2 (1UL << 17)  // AL Calculator (计算器) - 重复功能
#define IOS_KEY_BUTTON_FILE_BROWSER (1UL << 18) // AL Local Machine Browser (文件浏览器)
#define IOS_KEY_BUTTON_STOP        (1UL << 19)  // Stop (停止)
#define IOS_KEY_BUTTON_BOOKMARKS   (1UL << 20)  // AC Bookmarks (书签)
#define IOS_KEY_BUTTON_0x0307_2    (1UL << 21)  // 自定义功能 (0x0307) - 重复
#define IOS_KEY_BUTTON_AL_CONFIG   (1UL << 22)  // AL Consumer Control Configuration (控制配置)
#define IOS_KEY_BUTTON_POWER       (1UL << 23)  // Power (电源)

// 为了方便使用，也可以定义一些组合掩码
// #define KEY_MEDIA_GROUP (KEY_BUTTON_PREV_TRACK | KEY_BUTTON_PLAY_PAUSE | KEY_BUTTON_NEXT_TRACK | KEY_BUTTON_STOP)
// #define KEY_VOLUME_GROUP (KEY_BUTTON_VOL_UP | KEY_BUTTON_VOL_DOWN | KEY_BUTTON_MUTE)
// #define KEY_NAVIGATION_GROUP (KEY_BUTTON_HOME | KEY_BUTTON_BACK | KEY_BUTTON_SEARCH)






/**
 * @brief 发送数字化仪报告序列
 * @param points 数字化仪点数组，包含所有状态信息
 * @param count 点的数量
 * @param delay_units 每个点之间的延时单位数（每个单位约100us）
 */
void fill_digitizer_report_android(digitizer_point_t points[], uint8_t count, uint8_t * outbuffer)
{
    uint8_t conidx = 0; // 连接索引
    uint8_t raw_data[5] = {0};
    uint16_t hid_x, hid_y;
    
    for (uint8_t i = 0; i < count; i++) {
        // 转换坐标到HID格式
        // convert_to_hid_coord(points[i].x, points[i].y, &hid_x, &hid_y);
        // printf("Point %d - X:%d, Y:%d, hid_x:%d, hid_y:%d\r\n", 
        //        i, points[i].x, points[i].y, hid_x, hid_y);
        
        // 填充报告数据
        fill_digitizer_report_manual(points[i].x, points[i].y,
                                    points[i].tip_switch, points[i].in_range,
                                    points[i].barrel_switch, points[i].eraser,
                                    outbuffer);
        
        // 打印原始数据
        // printf("raw_data: ");
        // for(int j = 0; j < 5; j++) {
        //     printf("%02X ", outbuffer[j]);
        // }
        // printf("\r\n");
        
		#if 0
        // 发送报告
        hid_gatt_report_notify(conidx, 5, raw_data, 5);
        
        // 延时（最后一个点不延时）
        if (i < count - 1) {
            co_delay_100us(delay_units);
        }

		#endif
    }
}


/**
 * @brief 填充HID报告缓冲区（用于Report ID 2，24按钮版本）
 * @param button_mask 24位按钮位掩码，每个位对应一个按键状态
 * @param output_buffer 输出缓冲区（必须至少4字节）
 */
void fill_key_report_ios(uint32_t button_mask, uint8_t* output_buffer) {
    // 填充报告缓冲区
    // output_buffer[0] = 0x02;               // Report ID
    output_buffer[0] = button_mask & 0xFF;        // 第一个字节 (Bit 0-7)
    output_buffer[1] = (button_mask >> 8) & 0xFF;  // 第二个字节 (Bit 8-15)
    output_buffer[2] = (button_mask >> 16) & 0xFF; // 第三个字节 (Bit 16-23)
}




// 位5-7: 可定义其他按钮

/**
 */
void fill_key_report(uint8_t buttons, uint8_t* output_buffer) {

// 填充报告缓冲区
output_buffer[0] = buttons;       // 按钮状态字节
output_buffer[1] = 0x00 & 0xFF;  // X位移低字节

}



// 位5-7: 可定义其他按钮

/**
 * @brief 填充并生成Mouse报告 (Report ID 0x01)
 * @param buttons 按钮状态，按位组合（使用MOUSE_BUTTON_xxx宏）
 * @param rel_x X方向的相对位移（-2047 到 +2047）
 * @param rel_y Y方向的相对位移（-2047 到 +2047）
 * @param wheel 垂直滚轮位移（-127 到 +127）
 * @param pan 水平滚轮位移（-127 到 +127）
 * @param output_buffer 输出缓冲区，必须至少6字节大小
 * @return 无
 */
void fill_mouse_report(uint8_t buttons, int16_t rel_x, int16_t rel_y, 
                      int8_t wheel, int8_t pan, uint8_t* output_buffer) {
    
    // 确保位移量在有效范围内（可选，建议添加）
    rel_x = (rel_x < -2047) ? -2047 : (rel_x > 2047) ? 2047 : rel_x;
    rel_y = (rel_y < -2047) ? -2047 : (rel_y > 2047) ? 2047 : rel_y;
    wheel = (wheel < -127) ? -127 : (wheel > 127) ? 127 : wheel;
    pan = (pan < -127) ? -127 : (pan > 127) ? 127 : pan;

    // 填充报告缓冲区
    //output_buffer[0] = 0x01;          // Report ID (固定为0x01)
    output_buffer[0] = buttons;       // 按钮状态字节
    output_buffer[1] = rel_x & 0xFF;  // X位移低字节
    output_buffer[2] = rel_x >> 8;    // X位移高字节
    output_buffer[3] = rel_y & 0xFF;  // Y位移低字节
    output_buffer[4] = rel_y >> 8;    // Y位移高字节
    output_buffer[5] = wheel;         // 垂直滚轮
    output_buffer[6] = pan;           // 水平滚轮
}


/**
 * @brief 填充标准鼠标报告 (Report ID 0x04)
 * @param buttons 按钮状态: bit0-左键, bit1-右键, bit2-中键, bit3-后退, bit4-前进
 * @param wheel 垂直滚轮值: -127 到 +127
 * @param pan 水平滚轮值: -127 到 +127
 * @param output_buffer 输出缓冲区 (至少4字节)
 */
void fill_mouse_report_ios(uint8_t buttons, int8_t wheel, int8_t pan, uint8_t* output_buffer) {
    // 限制值在有效范围内
    wheel = (wheel < -127) ? -127 : (wheel > 127) ? 127 : wheel;
    pan = (pan < -127) ? -127 : (pan > 127) ? 127 : pan;
    
    // 只取按钮的低5位，高3位必须为0
    uint8_t button_byte = buttons /*& 0x1F*/;
    
    // 填充报告
    //output_buffer[0] = 0x04;      // Report ID
    output_buffer[0] = button_byte; // 按钮状态 (低5位有效，高3位为0)
    output_buffer[1] = (uint8_t)wheel;  // 垂直滚轮
    output_buffer[2] = (uint8_t)pan;    // 水平滚轮
}


/**
 * @brief 填充高精度指针报告 (Report ID 0x05)
 * @param rel_x X轴相对位移: -2047 到 +2047
 * @param rel_y Y轴相对位移: -2047 到 +2047
 * @param output_buffer 输出缓冲区 (至少3字节)
 */
void fill_hi_res_report_ios(int16_t rel_x, int16_t rel_y, uint8_t* output_buffer) {

    // 限制值在有效范围内
    rel_x = (rel_x < -2047) ? -2047 : (rel_x > 2047) ? 2047 : rel_x;
    rel_y = (rel_y < -2047) ? -2047 : (rel_y > 2047) ? 2047 : rel_y;

    // 限制范围，避免边界值问题
//		rel_x = (rel_x < -2040) ? -2040 : (rel_x > 2040) ? 2040 : rel_x;
//		rel_y = (rel_y < -2040) ? -2040 : (rel_y > 2040) ? 2040 : rel_y;
    

     // 直接使用位操作，C语言的类型转换会自动处理符号扩展
	 uint16_t x_12bit = (uint16_t)(rel_x & 0xFFF);  // 取低12位
	 uint16_t y_12bit = (uint16_t)(rel_y & 0xFFF);  // 取低12位
    
    // 填充报告（打包为3字节）
    //output_buffer[0] = 0x05;          // Report ID
    output_buffer[0] = x_12bit & 0xFF; // X低8位
    output_buffer[1] = ((x_12bit >> 8) & 0x0F) | ((y_12bit & 0x0F) << 4); // X高4位 + Y低4位
    output_buffer[2] = (y_12bit >> 4) & 0xFF; // Y高8位

}

void fill_finger_report_ios(uint8_t contact_id, uint16_t x, uint16_t y,
	bool press, uint8_t contact_count,
	uint8_t *output_buf)
{
// 状态字节
uint8_t state = 0x00;
if (press) {
state |= (1 << 0); // TipSwitch
state |= (1 << 1); // InRange
state |= (1 << 2); // InRange
}

output_buf[0] = state;

// Contact ID
output_buf[1] = contact_id;

// X (little endian)
output_buf[2] = (uint8_t)(x & 0xFF);
output_buf[3] = (uint8_t)((x >> 8) & 0xFF);

// Y (little endian)
output_buf[4] = (uint8_t)(y & 0xFF);
output_buf[5] = (uint8_t)((y >> 8) & 0xFF);

// Contact Count
output_buf[6] = contact_count;
}



/**
 * @brief 填充 Digitizer Finger 报告 (不含 Report ID)
 * @param contact_id   手指ID (一般=1即可)
 * @param x            绝对X坐标: 0 ~ 4095
 * @param y            绝对Y坐标: 0 ~ 4095
 * @param press        是否按下: true=按下, false=抬起
 * @param output_buf   输出缓冲区 (至少6字节)
 */


// Byte0: 状态 (bit0=TipSwitch, bit1=InRange, bit2~7保留)
// Byte1: Contact ID (1~5)
// Byte2-3: X (uint16, little endian)
// Byte4-5: Y (uint16, little endian)

void fill_finger_report(uint8_t contact_id, uint16_t x, uint16_t y,
	bool press, uint8_t *output_buf)
{
// 状态字节
// bit0 = TipSwitch, bit1 = InRange
uint8_t state = 0x00;
if (press) {
state |= (1 << 0); // TipSwitch
state |= (1 << 1); // InRange
}

output_buf[0] = state;
output_buf[1] = contact_id;

// X (little endian)
output_buf[2] = (uint8_t)(x & 0xFF);
output_buf[3] = (uint8_t)((x >> 8) & 0xFF);

// Y (little endian)
output_buf[4] = (uint8_t)(y & 0xFF);
output_buf[5] = (uint8_t)((y >> 8) & 0xFF);
}


/**
 * @brief 发送 Surface Switch 状态
 * @param connected true=连接, false=断开
 */
void send_surface_switch(bool connected) {

	#if 0
    uint8_t feature_report[1];
    
    //feature_report[0] = 0x05;          // Report ID 5
    feature_report[0] = connected ? 0x01 : 0x00;  // 状态字节
    
    // 使用 HID 的 Set_Feature 请求发送
    //send_feature_report(feature_report, 2);
	hid_gatt_report_notify(0, /*(id)*/ 4, feature_report, 1); // 发送
	co_delay_100us(delay_connect_send*1.25*8); // 具体延时API视系统而定
	#else


	uint8_t feature_report[1];
    feature_report[0] = connected ? 0x01 : 0x00;
    
    // 使用 HID 的 Set_Feature 请求发送
    //send_feature_report(feature_report, 2);
	hid_gatt_report_notify(0, /*(id)*/ 4, feature_report, 1); // 发送
	co_delay_100us(delay_connect_send*1.25*8); // 具体延时API视系统而定
	#endif
}
/**
 * @brief 填充手指触摸报告 (Report ID 9)
 * @param contact_id 触点ID (1-5)
 * @param contact_count 触点计数 (通常为1)
 * @param x X坐标 (0-4095)
 * @param y Y坐标 (0-4095)
 * @param press 是否按压
 * @param output_buf 输出缓冲区(至少7字节)
 */
void fill_finger_report_new_map(uint8_t contact_id, uint8_t contact_count, uint16_t x, uint16_t y,
	bool press, uint8_t *output_buf)
{

	#if 0
			// 字节0: 状态字节 (bit0=TipSwitch, bit1=Confidence, bits2-7=常量0)
			uint8_t state = 0x00;
			if (press) {
			state |= (1 << 0); // TipSwitch
			state |= (1 << 1); // Confidence
			}
			// bits 2-7 自动为0，符合描述符的常量填充要求
			output_buf[0] = state;

			// 字节1: Contact Identifier
			output_buf[1] = contact_id;

			// 字节2: Contact Count (新增)
			output_buf[2] = contact_count;

			// 字节3-4: X坐标 (小端序)
			output_buf[3] = (uint8_t)(x & 0xFF);
			output_buf[4] = (uint8_t)((x >> 8) & 0xFF);

			// 字节5-6: Y坐标 (小端序)
			output_buf[5] = (uint8_t)(y & 0xFF);
			output_buf[6] = (uint8_t)((y >> 8) & 0xFF);
			#else


    // 字节0: Button 1 (bit0) + Tip Switch (bit1) + Confidence (bit2) + 填充位 (bits3-7)
    uint8_t state = 0x00;
    if (press) {
        state |= (1 << 0); // Button 1 (iOS要求)
        state |= (1 << 1); // TipSwitch
        state |= (1 << 2); // Confidence
    }
    output_buf[0] = state;

    // 字节1: Contact Identifier
    output_buf[1] = contact_id;

    // 字节2: Contact Count
    output_buf[2] = contact_count;

    // 字节3-4: X坐标 (小端序)
    output_buf[3] = (uint8_t)(x & 0xFF);
    output_buf[4] = (uint8_t)((x >> 8) & 0xFF);

    // 字节5-6: Y坐标 (小端序)
    output_buf[5] = (uint8_t)(y & 0xFF);
    output_buf[6] = (uint8_t)((y >> 8) & 0xFF);

    // 字节7: 保留字节 (填充0)
    output_buf[7] = 0x00;
	#endif
}





// 绝对坐标鼠标点数据结构
typedef struct {
    uint8_t buttons;    // 按钮状态
    uint16_t abs_x;     // 绝对X坐标 (0-4095)
    uint16_t abs_y;     // 绝对Y坐标 (0-4095)
    int8_t wheel;       // 垂直滚轮 (-127 to +127) - 可选
    int8_t pan;         // 水平滚轮 (-127 to +127) - 可选
} abs_mouse_point_t;

/**
 * @brief 填充绝对坐标鼠标报告
 * @param buttons 按钮状态
 * @param abs_x 绝对X坐标 (0-4095)
 * @param abs_y 绝对Y坐标 (0-4095)
 * @param wheel 垂直滚轮位移
 * @param pan 水平滚轮位移
 * @param output_buffer 输出缓冲区（8字节）
 */
void fill_abs_mouse_report(uint8_t buttons, uint16_t abs_x, uint16_t abs_y, 
                          int8_t wheel, int8_t pan, uint8_t* output_buffer) {
    
    // 确保坐标在有效范围内
    abs_x = (abs_x > 4095) ? 4095 : abs_x;
    abs_y = (abs_y > 4095) ? 4095 : abs_y;
    wheel = (wheel < -127) ? -127 : (wheel > 127) ? 127 : wheel;
    pan = (pan < -127) ? -127 : (pan > 127) ? 127 : pan;

    // 填充报告数据（小端序）
   
    output_buffer[0] = buttons;       // 按钮状态
    output_buffer[1] = abs_x & 0xFF;  // X低字节
    output_buffer[2] = abs_x >> 8;    // X高字节
    output_buffer[3] = abs_y & 0xFF;  // Y低字节
    output_buffer[4] = abs_y >> 8;    // Y高字节
    output_buffer[5] = wheel;         // 垂直滚轮
    output_buffer[6] = pan;           // 水平滚轮
}

/**
 * @brief 发送绝对坐标鼠标序列
 * @param points 绝对坐标点数组
 * @param count 点的数量
 * @param delay_ms 每个点之间的延时（毫秒）
 */
void send_abs_mouse_sequence(abs_mouse_point_t points[], uint8_t count, uint16_t delay_ms) {
    uint8_t raw_data[7] = {0};
    
    for (uint8_t i = 0; i < count; i++) {
        fill_abs_mouse_report(points[i].buttons, points[i].abs_x, points[i].abs_y,
                             points[i].wheel, points[i].pan, raw_data);
        
        // 发送报告（需要实现hid_send_report函数）
        //hid_send_report(0x01, raw_data, 7);


		hid_gatt_report_notify(0,0, raw_data, 7);
        
        // 延时（最后一个点不延时）
        if (i < count - 1 && delay_ms > 0) {
			co_delay_100us(10*delay_ms); // 具体延时API视系统而定
		
        }
    }
}






void fill_digitizer_report_manual(uint16_t x, uint16_t y,
	uint8_t tip_switch, uint8_t in_range,
	uint8_t barrel_switch, uint8_t eraser,
	uint8_t* output_buffer) {

	// 1. 构造状态字节
	output_buffer[0] = (tip_switch & 0x01) |
	((in_range & 0x01) << 1) |
	((barrel_switch & 0x01) << 5) |
	((eraser & 0x01) << 6);

	(tip_switch & 0x01)?output_buffer[0]|=(0x01 << 2): output_buffer[0]&(~((0x01 << 2)));

	// 2. 赋值X坐标 (小端模式：低字节在前)
	output_buffer[1] = (uint8_t)(x & 0xFF);       // 低字节
	output_buffer[2] = (uint8_t)((x >> 8) & 0xFF); // 高字节

	// 3. 赋值Y坐标 (小端模式：低字节在前)
	output_buffer[3] = (uint8_t)(y & 0xFF);       // 低字节
	output_buffer[4] = (uint8_t)((y >> 8) & 0xFF); // 高字节
}

/**
 * @brief 发送数字化仪报告序列
 * @param points 数字化仪点数组，包含所有状态信息
 * @param count 点的数量
 * @param delay_units 每个点之间的延时单位数（每个单位约100us）
 */
void send_digitizer_sequence(digitizer_point_t points[], uint8_t count, uint16_t delay_units)
{
    uint8_t conidx = 0; // 连接索引
    uint8_t raw_data[5] = {0};
    uint16_t hid_x, hid_y;
    
    for (uint8_t i = 0; i < count; i++) {
        // 转换坐标到HID格式
        convert_to_hid_coord(points[i].x, points[i].y, &hid_x, &hid_y);
        printf("Point %d - X:%d, Y:%d, hid_x:%d, hid_y:%d\r\n", 
               i, points[i].x, points[i].y, hid_x, hid_y);
        
        // 填充报告数据
        fill_digitizer_report_manual(points[i].x, points[i].y,
                                    points[i].tip_switch, points[i].in_range,
                                    points[i].barrel_switch, points[i].eraser,
                                    raw_data);
        
        // 打印原始数据
        printf("raw_data: ");
        for(int j = 0; j < 5; j++) {
            printf("%02X ", raw_data[j]);
        }
        printf("\r\n");
        
        // 发送报告
        hid_gatt_report_notify(conidx, 5, raw_data, 5);
        
        // 延时（最后一个点不延时）
        if (i < count - 1) {
            co_delay_100us(delay_units);
        }
    }
}






#if 1


/**
 * @brief 填充数字化仪报告（iOS兼容格式，8字节）
 * @param x X坐标 (应该是0-4095范围)
 * @param y Y坐标 (应该是0-4095范围) 
 * @param tip_switch 触点按下状态
 * @param in_range 在感应范围内状态
 * @param contact_id 触点标识符
 * @param contact_count 触点数量
 * @param output_buffer 输出缓冲区（8字节）
 */
void fill_digitizer_report_ios(uint16_t x, uint16_t y,
    uint8_t tip_switch, uint8_t in_range,
    uint8_t contact_id, uint8_t contact_count,
    uint8_t* output_buffer) {


    // 1. 状态字节 (Bit 0: Tip Switch, Bit 1: In Range, Bits 2-7: 填充0)
    output_buffer[0] = (tip_switch & 0x01) | ((in_range & 0x01) << 1);
	(tip_switch & 0x01)?output_buffer[0]|=(0x01 << 2): output_buffer[0]&(~((0x01 << 2)));
    // 2. X坐标 (小端模式：低字节在前)
    output_buffer[1] = (uint8_t)(x & 0xFF);        // 低字节
    output_buffer[2] = (uint8_t)((x >> 8) & 0xFF); // 高字节
    
    // 3. Y坐标 (小端模式：低字节在前)
    output_buffer[3] = (uint8_t)(y & 0xFF);        // 低字节  
    output_buffer[4] = (uint8_t)((y >> 8) & 0xFF); // 高字节
    
    // 4. Contact ID (必需字段)
    output_buffer[5] = contact_id;
    
    // 5. Contact Count (触点数量)
    output_buffer[6] = contact_count;
    
    // 6. 保留字节（填充0）
    output_buffer[7] = 0x00;
}

/**
 * @brief 发送数字化仪报告序列（iOS兼容格式）
 */
void send_digitizer_sequence_ios(digitizer_point_t points[], uint8_t count, uint16_t delay_units)
{
    uint8_t conidx = 0;
    uint8_t raw_data[8] = {0};
    
    for (uint8_t i = 0; i < count; i++) {
        // 直接使用原始坐标，确保在0-4095范围内
        uint16_t hid_x = points[i].x;
        uint16_t hid_y = points[i].y;
        
        printf("Point %d - X:%d, Y:%d\r\n", i, hid_x, hid_y);
        
        // 填充报告数据
//        fill_digitizer_report_ios(
//            hid_x, hid_y,                       // 坐标 (0-4095)
//            points[i].tip_switch,               // Tip Switch
//            points[i].in_range,                 // In Range  
//            points[i].contact_id,               // Contact ID
//            points[i].contact_count,            // Contact Count
//            raw_data
//        );
        
        // 打印原始数据
        printf("raw_data: ");
        for(int j = 0; j < 8; j++) {
            printf("%02X ", raw_data[j]);
        }
        printf("\r\n");
        
        // 发送报告 - 关键修改：Report ID是6，长度8字节
        hid_gatt_report_notify(conidx, 5, raw_data, 8);
        
        // 延时
        if (i < count - 1) {
            co_delay_100us(delay_units);
        }
    }
}





#else

/**
 * @brief 填充数字化仪报告（iOS兼容格式，8字节）
 * @param x X坐标 (0-4095)
 * @param y Y坐标 (0-4095)
 * @param tip_switch 触点按下状态
 * @param in_range 在感应范围内状态
 * @param contact_id 触点标识符 (必需)
 * @param contact_count 触点数量 (0或1)
 * @param output_buffer 输出缓冲区（至少8字节）
 */
void fill_digitizer_report_ios(uint16_t x, uint16_t y,
    uint8_t tip_switch, uint8_t in_range,
    uint8_t contact_id, uint8_t contact_count,
    uint8_t* output_buffer) {

    // 1. 状态字节 (Bit 0: Tip Switch, Bit 1: In Range, Bits 2-7: 填充0)
    output_buffer[0] = (tip_switch & 0x01) | ((in_range & 0x01) << 1);
    // 注意：barrel_switch 和 eraser 在iOS触摸板协议中通常不需要

    // 2. X坐标 (小端模式)
    output_buffer[1] = (uint8_t)(x & 0xFF);       // 低字节
    output_buffer[2] = (uint8_t)((x >> 8) & 0xFF); // 高字节

    // 3. Y坐标 (小端模式)
    output_buffer[3] = (uint8_t)(y & 0xFF);       // 低字节
    output_buffer[4] = (uint8_t)((y >> 8) & 0xFF); // 高字节

    // 4. Contact ID (必需字段)
    output_buffer[5] = contact_id & 0xFF;

    // 5. Contact Count (必需字段)
    output_buffer[6] = contact_count & 0xFF;

    // 6. 可选：第7字节可以保留为0或其他用途
    output_buffer[7] = 0x00;
}

/**
 * @brief 发送数字化仪报告序列（iOS兼容格式）
 * @param points 数字化仪点数组
 * @param count 点的数量
 * @param delay_units 每个点之间的延时
 */
void send_digitizer_sequence_ios(digitizer_point_t points[], uint8_t count, uint16_t delay_units)
{
    uint8_t conidx = 0; // 连接索引
    uint8_t raw_data[8] = {0}; // 改为8字节缓冲区
    uint16_t hid_x, hid_y;
    
    for (uint8_t i = 0; i < count; i++) {
        // 转换坐标到HID格式 (如果需要)
        convert_to_hid_coord(points[i].x, points[i].y, &hid_x, &hid_y);
        printf("Point %d - X:%d, Y:%d, hid_x:%d, hid_y:%d\r\n", 
               i, points[i].x, points[i].y, hid_x, hid_y);
        
        // 填充报告数据 (8字节格式)
        fill_digitizer_report_ios(
            hid_x, hid_y,                       // 坐标
            points[i].tip_switch,               // Tip Switch
            points[i].in_range,                 // In Range
            points[i].contact_id,               // Contact ID (必需)
            (i == 0) ? 1 : 0,                   // Contact Count: 第一个点为1，其他为0
            raw_data                            // 输出缓冲区
        );
        
        // 打印原始数据
        printf("raw_data: ");
        for(int j = 0; j < 8; j++) {
            printf("%02X ", raw_data[j]);
        }
        printf("\r\n");
        
        // 发送报告 (改为8字节)
        hid_gatt_report_notify(conidx, 6, raw_data, 8); // 注意：Report ID是6
        
        // 延时（最后一个点不延时）
        if (i < count - 1) {
            co_delay_100us(delay_units);
        }
    }
}


#endif
















/**
 * @brief 发送单个数字化仪报告点
 * @param point 数字化仪点结构体
 */
void send_digitizer_point(digitizer_point_t point)
{
    uint8_t conidx = 0;
    uint8_t raw_data[5] = {0};
    uint16_t hid_x, hid_y;
    
    convert_to_hid_coord(point.x, point.y, &hid_x, &hid_y);
    printf("X:%d, Y:%d, hid_x:%d, hid_y:%d\r\n", point.x, point.y, hid_x, hid_y);
    
    fill_digitizer_report_manual(point.x, point.y, point.tip_switch, point.in_range, 
                                point.barrel_switch, point.eraser, raw_data);
    
    printf("raw_data: ");
    for(int i = 0; i < 5; i++) {
        printf("%02X ", raw_data[i]);
    }
    printf("\r\n");
    
    hid_gatt_report_notify(conidx, 5, raw_data, 5);
}


#if 0

// 示例：模拟笔尖从(1000,700)移动到(1000,900)然后释放
void example_pen_movement(void)
{
    // 定义数字化仪点序列（所有状态都封装在结构体数组中）
    digitizer_point_t points[] = {
        // X,    Y,    tip, in_range, barrel, eraser
        {1000, 700, 1, 1, 0, 0},  // 点1：按下，在位
        {1000, 800, 1, 1, 0, 0},  // 点2：按下，在位
        {1000, 900, 1, 1, 0, 0},  // 点3：按下，在位
        {1000, 900, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
        {1000, 900, 0, 0, 0, 0}   // 点5：完全释放
    };
    
    // 发送序列，每个点之间延时20个单位（约2ms）
    send_digitizer_sequence(points, 5, 20);
}

// 示例：模拟简单的点击操作
void example_simple_click(void)
{
    digitizer_point_t click_sequence[] = {
        // X,    Y,    tip, in_range, barrel, eraser
        {500, 500, 0, 1, 0, 0},  // 接近但未按下
        {500, 500, 1, 1, 0, 0},  // 按下
        {500, 500, 0, 1, 0, 0},  // 释放但仍在位
        {500, 500, 0, 0, 0, 0}   // 完全离开
    };
    
    send_digitizer_sequence(click_sequence, 4, 15);
}

// 示例：使用单个点发送函数
void example_single_points(void)
{
    digitizer_point_t point1 = {1000, 700, 1, 1, 0, 0};
    send_digitizer_point(point1);
    co_delay_100us(20);
    
    digitizer_point_t point2 = {1000, 800, 1, 1, 0, 0};
    send_digitizer_point(point2);
    co_delay_100us(20);
    
    digitizer_point_t point3 = {1000, 900, 1, 1, 0, 0};
    send_digitizer_point(point3);
    co_delay_100us(20);
    
    digitizer_point_t release_point = {1000, 900, 0, 0, 0, 0};
    send_digitizer_point(release_point);
}



#endif



/*
 * TYPEDEFS 
 */

/*
 * GLOBAL VARIABLES 
 */
uint16_t user_task_id;
uint16_t audio_task_id;
uint16_t key_send_task_id;  // 新增按键发送任务ID





/*********************************************************************
 * @fn      user_task_func
 *
 * @brief   Button task function, handles button events.
 *
 * @param   param   - OS events of buttons.
 *       
 *
 * @return  int     - EVT_CONSUMED.
 */
static int user_task_func(os_event_t *param)
{
    switch(param->event_id)
    {
        case USER_EVT_BUTTON:
            {
                struct button_msg_t *button_msg;
                const char *button_type_str[] = {
                                                    "BUTTON_PRESSED",
                                                    "BUTTON_RELEASED",
                                                    "BUTTON_SHORT_PRESSED",
                                                    "BUTTON_MULTI_PRESSED",
                                                    "BUTTON_LONG_PRESSED",
                                                    "BUTTON_LONG_PRESSING",
                                                    "BUTTON_LONG_RELEASED",
                                                    "BUTTON_LONG_LONG_PRESSED",
                                                    "BUTTON_LONG_LONG_RELEASED",
                                                    "BUTTON_COMB_PRESSED",
                                                    "BUTTON_COMB_RELEASED",
                                                    "BUTTON_COMB_SHORT_PRESSED",
                                                    "BUTTON_COMB_LONG_PRESSED",
                                                    "BUTTON_COMB_LONG_PRESSING",
                                                    "BUTTON_COMB_LONG_RELEASED",
                                                    "BUTTON_COMB_LONG_LONG_PRESSED",
                                                    "BUTTON_COMB_LONG_LONG_RELEASED",
                                                };
                button_msg = (struct button_msg_t *)param->param;
                co_printf("KEY 0x%08x, TYPE %s.\r\n", button_msg->button_index, button_type_str[button_msg->button_type]);
				
								
				if(button_msg->button_type == BUTTON_LONG_RELEASED){
					// if(devices_config.mode.mode == REMOTE_MODE){
					// 	pmu_set_led1_value(0); 
					// }else  if(devices_config.mode.mode == MUSIC_MODE){
					// }

						pmu_set_led1_value(0); 
						pmu_set_led2_value(0); 


				}


				if(button_msg->button_type ==BUTTON_MULTI_PRESSED){

					
					pmu_set_led1_value(0); 
					pmu_set_led2_value(0); 

					
						pmu_set_led1_value(0); 
						pmu_set_led2_value(0); 

						if(!connection_initialized){
							return 0;
						}


						if(button_msg->button_index == UP_KEY){

							
							uint8_t raw_data[5] = {0};
							if(func_mode){
								if (!ios_devices){
									fill_key_report(KEY_BUTTON_VOL_UP,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 2);
								}else{

									
									fill_key_report_ios(IOS_KEY_BUTTON_VOL_UP,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 3);

									fill_key_report_ios(0,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 3);
								}	
								return 0;
							}

						}else
						if(button_msg->button_index == DOWN_KEY){
							
							uint8_t raw_data[5] = {0};
							if(func_mode){

								if (!ios_devices){
								 fill_key_report(KEY_BUTTON_VOL_DOWN,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 2);

							}else{

									
								fill_key_report_ios(IOS_KEY_BUTTON_VOL_DOWN,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 3);

								fill_key_report_ios(0,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 3);
							}



								return 0;
							}

						}else
						if(button_msg->button_index == LEFT_KEY){

							uint8_t raw_data[5] = {0};
							if(func_mode){
			
								if (!ios_devices){
								// fill_key_report(KEY_BUTTON_VOL_POWER,raw_data); 
								fill_key_report(KEY_BUTTON_Previous,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 2);
			
							}else{
			
								fill_key_report_ios(IOS_KEY_BUTTON_PREV_TRACK,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 3);
								fill_key_report_ios(0,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 3);
			
							}
			
								return 0;
							}

						}else
						if(button_msg->button_index == RIGHT_KEY){

							uint8_t raw_data[5] = {0};
							if(func_mode){
									
													
								if (!ios_devices){
								//  fill_key_report(KEY_BUTTON_VOL_MENU,raw_data); 
			
								fill_key_report(KEY_BUTTON_Next,raw_data); 
			
								hid_gatt_report_notify(0,2, raw_data, 2);
								}else{
			
											
									fill_key_report_ios(IOS_KEY_BUTTON_NEXT_TRACK,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 3);
			
									fill_key_report_ios(0,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 3);
								}
			
			
								return 0;
							}

						}else

						if(button_msg->button_index == PICTURE_KEY){

							
							uint8_t raw_data[5] = {0};
							if(func_mode){
								if (!ios_devices){
									if(button_msg->button_cnt == 2){
										fill_key_report(KEY_BUTTON_VOL_HOME,raw_data); 
										hid_gatt_report_notify(0,2, raw_data, 2);
									}	else if(button_msg->button_cnt == 3){
										fill_key_report(KEY_BUTTON_VOL_POWER,raw_data); 
										hid_gatt_report_notify(0,2, raw_data, 2);
									}
								}else{



									uint8_t raw_data[3] = {0};

									if(button_msg->button_cnt == 2){
										
											fill_mouse_report_ios(MOUSE_BUTTON_KEY_PICTURE, 0, 0, raw_data);
											//add_mouse_report_to_buffer(3, raw_data, 3);
											hid_gatt_report_notify(0,3, raw_data, 3);
			
											fill_mouse_report_ios(0, 0, 0, raw_data);
											//add_mouse_report_to_buffer(3, raw_data, 3);
											hid_gatt_report_notify(0,3, raw_data, 3);
			
										
									}else if(button_msg->button_cnt == 3){

										fill_mouse_report_ios(MOUSE_BUTTON_MIDDLE, 0, 0, raw_data);
										//add_mouse_report_to_buffer(3, raw_data, 3);
										hid_gatt_report_notify(0,3, raw_data, 3);
		
										fill_mouse_report_ios(0, 0, 0, raw_data);
										//add_mouse_report_to_buffer(3, raw_data, 3);
										hid_gatt_report_notify(0,3, raw_data, 3);

									}

									
									// fill_key_report_ios(IOS_KEY_BUTTON_HOME,raw_data); 
									// hid_gatt_report_notify(0,2, raw_data, 3);

									// fill_key_report_ios(0,raw_data); 
									// hid_gatt_report_notify(0,2, raw_data, 3);
								}	
								return 0;
							}

						}else



							if(button_msg->button_index == OK_KEY){

							uint8_t raw_data[5] = {0};
							if(func_mode){
									
													
								if (!ios_devices){



									#if 1



					// ??????????????
										if (last_pressed_key != OK_KEY) {
											// ????????????????eset_init_poszation
											// if (connection_initialized) {
											// 	reset_init_poszation(false);
											// 	reset_x_y = true;
											// }
											last_pressed_key = OK_KEY;
										}
										
										// ????????
										//os_timer_start(&key_send_timer,2,false);
											// ???????????????????
						os_event_t evt = {
							.event_id = USER_EVT_KEY_SEND,
							.src_task_id = 0,
							.param = NULL,
							.param_len = 0
						};
				os_msg_post(key_send_task_id, &evt);
			

									#else
										digitizer_point_t points[] = {
										// X,    Y,    tip, in_range, barrel, eraser
										// //{1000, 1400, 0, 1, 1, 1},  // ??4???????????????????????????
										// {500, 1600, 1, 1, 0, 0},  // ??3?????????
										// {600, 1600, 1, 1, 0, 0},  // ??3?????????
										// {700, 1600, 1, 1, 0, 0},  // ??3?????????
										// {800, 1600, 1, 1, 0, 0},  // ??3?????????
										// {900, 1600, 1, 1, 0, 0},  // ??3?????????
										// {1000, 1600, 1, 1, 0, 0},  // ??3?????????
										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // ??1?????????
										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 1, 0, 0},   // ??5????????
										// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0},   // ??5????????
										// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0},   // ??5????????

										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // ??1?????????
										// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0},  // ??5????????
										// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0},   // ??5????????
										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 1, 0, 0},   // ??5????????

									
									};
									send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);

									#endif


								//  fill_key_report(KEY_BUTTON_VOL_MENU,raw_data); 
								// fill_key_report(KEY_BUTTON_Next,raw_data); 
			
								// hid_gatt_report_notify(0,2, raw_data, 2);
								}else{



									uint8_t raw_data[3] = {0};
									for(int i = 0;i < 1;i++){
										fill_mouse_report_ios(MOUSE_BUTTON_RIGHT, 0, 0, raw_data);
										//add_mouse_report_to_buffer(3, raw_data, 3);
										hid_gatt_report_notify(0,3, raw_data, 3);
		
			
										fill_mouse_report_ios(0, 0, 0, raw_data);
										//add_mouse_report_to_buffer(3, raw_data, 3);
										hid_gatt_report_notify(0,3, raw_data, 3);
		
									}
			
											
									// fill_key_report_ios(IOS_KEY_BUTTON_NEXT_TRACK,raw_data); 
									// hid_gatt_report_notify(0,2, raw_data, 3);
			
									// fill_key_report_ios(0,raw_data); 
									// hid_gatt_report_notify(0,2, raw_data, 3);
								}
			
			
								return 0;
							}

						}


				}
				
				if(button_msg->button_type == BUTTON_COMB_LONG_PRESSED){

					if(devices_config.mode.mode == REMOTE_MODE){

						if(button_msg->button_index == ((OK_KEY)|(UP_KEY))){

							

							if(devices_config.mode.pos_set_mode == NONE_SETTING_MODE){

								devices_config.mode.pos_set_mode = SCROLL_POS_SETTING_MODE;
							}
							else if(devices_config.mode.pos_set_mode == SCROLL_POS_SETTING_MODE){

								devices_config.mode.pos_set_mode = NONE_SETTING_MODE;
							}


							printf("current pos mode %d\r\n",devices_config.mode.pos_set_mode);

							pmu_set_led1_value(0); 
							pmu_set_led2_value(0); 

							int i  = 3;
							while (i--)
							{
								/* code */
								pmu_set_led2_value(1); 
								co_delay_100us(500);
								pmu_set_led2_value(0); 
								co_delay_100us(500);
							}
							
							
						}

						#if 0
						if(button_msg->button_index == ((PICTURE_KEY)|(UP_KEY))){
								

							if(devices_config.mode.pos_set_mode == NONE_SETTING_MODE){

								devices_config.mode.pos_set_mode = SCROLL_POS_PICTURE_SETTING_MODE;
							}
							else if(devices_config.mode.pos_set_mode == SCROLL_POS_PICTURE_SETTING_MODE){

								devices_config.mode.pos_set_mode = NONE_SETTING_MODE;
							}





							printf("current picture mode %d\r\n",devices_config.mode.pos_set_mode);

						}
						#endif
					}
				}
				if(button_msg->button_type == BUTTON_LONG_PRESSED){


					if(button_msg->button_index == OK_KEY){

							if(devices_config.mode.mode == REMOTE_MODE){
								devices_config.mode.mode = MUSIC_MODE;

							}else if(devices_config.mode.mode == MUSIC_MODE){
								devices_config.mode.mode = REMOTE_MODE;
							}


							pmu_set_led1_value(0); 
							pmu_set_led2_value(0); 

							int i  = 3;
							while (i--)
							{
								/* code */
								pmu_set_led1_value(1); 
								co_delay_100us(500);
								pmu_set_led1_value(0); 
								co_delay_100us(500);
							}

							printf("current mode %d\r\n",devices_config.mode.mode);
					}

				}

				if
				(
					//(button_msg->button_type == BUTTON_LONG_LONG_RELEASED)||
					//(button_msg->button_type == )||
					//(button_msg->button_type == BUTTON_LONG_RELEASED)||
					//(button_msg->button_type == BUTTON_SHORT_PRESSED) ||
					(button_msg->button_type == BUTTON_PRESSED)        
					
				
				
				){
					printf("BUTTON_PRESSED\r\n");

					if(devices_config.mode.mode == REMOTE_MODE){
						pmu_set_led1_value(1); 
					}else  if(devices_config.mode.mode == MUSIC_MODE){
						pmu_set_led2_value(1); 
					}
				
				}
				if(button_msg->button_type == BUTTON_SHORT_PRESSED){//̰
					printf("BUTTON_RELEASED\r\n");


					
		
					if(devices_config.mode.mode == REMOTE_MODE){
						pmu_set_led1_value(0); 
					}else  if(devices_config.mode.mode == MUSIC_MODE){
						pmu_set_led2_value(0); 
					}


					if(!connection_initialized){
							return 0;
					}


					// 检查 data_ringbuf 是否为空，如果为空则继续执行，如果有数据则忽略
					if (data_ringbuf != NULL && !y_ringbuf_is_empty(data_ringbuf)) {
						// 如果 ringbuf 有数据，则忽略此次按键事件，防止数据插入异常
						return 0;
					}


					int i= 0;
					 if(button_msg->button_index == UP_KEY){

						co_printf("UP_KEY  Pressed\r\n");
						
							if(devices_config.mode.mode == REMOTE_MODE){


								if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){
									
									uint8_t raw_data[7] = {0}; // 存储最终的5字节数据

														
									if (!ios_devices){

													devices_config.offset_point_config[current_device_index].y_offset -= 100;

													if (devices_config.offset_point_config[current_device_index].y_offset<=0)
													{
													devices_config.offset_point_config[current_device_index].y_offset = 0;
													}

												digitizer_point_t points[] = {
													// X,    Y,    tip, in_range, barrel, eraser
													// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
													// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
													// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
													// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
													// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
													// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
													// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
													{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
												};
												send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
																
										}else{
											fill_hi_res_report_ios(0, -20, raw_data);
											hid_gatt_report_notify(0,4, raw_data, 3);
										}


									return 0;
								}

								if(ios_devices){

														
															// 检查是否是新的按键
															if (last_pressed_key != UP_KEY) {

																last_pressed_key = UP_KEY;
																// 如果按键不同，先发送reset_init_poszation
																if (connection_initialized) {

																	printf("-------------------0-----------------\r\n");
																	reset_init_poszation(false);


																	reset_x_y = true;
																}
															
															}
															
															// 启动定时器
															//os_timer_start(&key_send_timer,2,false);
																// 发送消息到按键发送任务
															os_event_t evt = {
																.event_id = USER_EVT_KEY_SEND,
																.src_task_id = 0,
																.param = NULL,
																.param_len = 0
															};
															os_msg_post(key_send_task_id, &evt);
												}	
												else   //android
											{

												
												if (last_pressed_key != UP_KEY) {

													last_pressed_key = UP_KEY;
												
												
												}




												uint32_t key_type =  UP_KEY;
												os_event_t evt = {
													.event_id = USER_EVT_KEY_SEND,
													.src_task_id = 0,
													.param = &key_type,
													.param_len = 0
												};
												os_msg_post(key_send_task_id, &evt);
											
															#if 0
															// 发送序列，每个点之间延时20个单位（约5ms）
															 //hid touch 
																// 定义数字化仪点序列（所有状态都封装在结构体数组中）
																digitizer_point_t points[] = {
																// X,    Y,    tip, in_range, barrel, eraser
																#if 1

																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 0  , 1, 1, 0, 0},  // 点1：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 100, 1, 1, 0, 0},  // 点2：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 200, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 300, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 400, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 500, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 600, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 700, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 800, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 900, 1, 1, 0, 0},  // 点3：按下，在位
																{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 900, 0, 0, 0, 0}   // 点5：完全释放
																#else
																// {1000, 700, 1, 1, 0, 0},  // 点1：按下，在位
																// {1000, 800, 1, 1, 0, 0},  // 点2：按下，在位
																// {1000, 900, 1, 1, 0, 0},  // 点3：按下，在位
																// {1000, 1000, 1, 1, 0, 0},  // 点3：按下，在位
																// {1000, 1100, 1, 1, 0, 0},  // 点3：按下，在位
																// {1000, 1200, 1, 1, 0, 0},  // 点3：按下，在位
																// {1000, 1300, 1, 1, 0, 0},  // 点3：按下，在位
																// {1000, 1400, 1, 1, 0, 0},  // 点3：按下，在位
																// {1000, 1500, 1, 1, 0, 0},  // 点3：按下，在位
															    // {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
																// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
																// {1000, 1600, 0, 0, 0, 0}   // 点5：完全释放
																#endif
																};
														send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);	
														#endif				
											}
							}else if(devices_config.mode.mode == MUSIC_MODE){

								uint8_t raw_data[5] = {0};
								if(func_mode){
									if (!ios_devices){
										fill_key_report(KEY_BUTTON_VOL_UP,raw_data); 
										hid_gatt_report_notify(0,2, raw_data, 2);
									}else{
	
										
										fill_key_report_ios(IOS_KEY_BUTTON_VOL_UP,raw_data); 
										hid_gatt_report_notify(0,2, raw_data, 3);
	
										fill_key_report_ios(0,raw_data); 
										hid_gatt_report_notify(0,2, raw_data, 3);
									}	
									return 0;
								}

							}

						}		
			 		
					if(button_msg->button_index == DOWN_KEY){//KEY2 模式切换
				 
								co_printf("DOWN_KEY  Pressed\r\n");

								if(devices_config.mode.mode == REMOTE_MODE){
										//hid mouse 相对
										uint8_t raw_data[7] = {0}; // 存储最终的5字节数据

										if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){
								
											if (!ios_devices){


											
												devices_config.offset_point_config[current_device_index].y_offset += 100;
												
												if (devices_config.offset_point_config[current_device_index].y_offset>4095)
												{
													devices_config.offset_point_config[current_device_index].y_offset = 4095;
												}
			
											digitizer_point_t points[] = {
												// X,    Y,    tip, in_range, barrel, eraser
												// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
												// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
												// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
												// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
												// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
												// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
												// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
												{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
											};
											send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
									
										}else{
											fill_hi_res_report_ios(0, 20, raw_data);
											hid_gatt_report_notify(0,4, raw_data, 3);
										}

											return 0;
										}


										if(ios_devices){
												// 检查是否是新的按键
												if (last_pressed_key != DOWN_KEY) {
													last_pressed_key = DOWN_KEY;
													// 如果按键不同，先发送reset_init_poszation
													if (connection_initialized) {
														reset_init_poszation(false);
														reset_x_y = true;
													}
												
												}
												
												// 启动定时器
												//os_timer_start(&key_send_timer,2,false);
													// 发送消息到按键发送任务
													os_event_t evt = {
														.event_id = USER_EVT_KEY_SEND,
														.src_task_id = 0,
														.param = NULL,
														.param_len = 0
													};
													os_msg_post(key_send_task_id, &evt);
											
										}else
										{



													// 检查是否是新的按键
													if (last_pressed_key != DOWN_KEY) {
														last_pressed_key = DOWN_KEY;
														
													}

													uint32_t key_type =  DOWN_KEY;
													os_event_t evt = {
														.event_id = USER_EVT_KEY_SEND,
														.src_task_id = 0,
														.param = &key_type,
														.param_len = 0
													};
													os_msg_post(key_send_task_id, &evt);
											
											// // 定义数字化仪点序列（所有状态都封装在结构体数组中）
											// digitizer_point_t points[] = {
											// 	// X,    Y,    tip, in_range, barrel, eraser									
											// 	#if 1

											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 900 , 1, 1, 0, 0},  // 点1：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 800, 1, 1, 0, 0},  // 点2：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 700, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 600, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 500, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 400, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 300, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 200, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 100, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 0  , 1, 1, 0, 0},  // 点3：按下，在位
											// 	{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 0, 0, 0, 0, 0}   // 点5：完全释放
											// 	#else
											// 	//{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
											// 	{1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 1500, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 1400, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 1300, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 1200, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 1100, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 1000, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 900, 1, 1, 0, 0},  // 点3：按下，在位
											// 	{1000, 800, 1, 1, 0, 0},  // 点2：按下，在位
											// 	{1000, 700, 0, 0, 0, 0},  // 点1：按下，在位
											// 	#endif
											// };
											// send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
											

										}
							}else if(devices_config.mode.mode == MUSIC_MODE){
								uint8_t raw_data[5] = {0};
								if(func_mode){

									if (!ios_devices){
 									fill_key_report(KEY_BUTTON_VOL_DOWN,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 2);

								}else{

										
									fill_key_report_ios(IOS_KEY_BUTTON_VOL_DOWN,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 3);

									fill_key_report_ios(0,raw_data); 
									hid_gatt_report_notify(0,2, raw_data, 3);
								}



									return 0;
								}
							}

			 }

			 if(button_msg->button_index == LEFT_KEY){
				co_printf("LEFT_KEY  Pressed\r\n");


				if(devices_config.mode.mode == REMOTE_MODE){
				//hid mouse 相对
				uint8_t raw_data[7] = {0}; // 存储最终的5字节数据

				if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){
								
					//x 偏移 //y 偏移
					if (!ios_devices){
						devices_config.offset_point_config[current_device_index].x_offset  -= 100;
				
						if (devices_config.offset_point_config[current_device_index].x_offset<0)
						{
							devices_config.offset_point_config[current_device_index].x_offset = 0;
						}
						digitizer_point_t points[] = {
							// X,    Y,    tip, in_range, barrel, eraser
							// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
							// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
							// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
							// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
							// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
							// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
							// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
							{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
						};
						send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
				
					}else{
						fill_hi_res_report_ios(-20, 0, raw_data);
						hid_gatt_report_notify(0,4, raw_data, 3);

					}
					return 0;
				}

				if(ios_devices)
				
				{
					// 检查是否是新的按键
										if (last_pressed_key != LEFT_KEY) {
											// 如果按键不同，先发送reset_init_poszation
											if (connection_initialized) {
												reset_init_poszation(false);
												reset_x_y = true;
											}
											last_pressed_key = LEFT_KEY;
										}
										
										// 启动定时器
										//os_timer_start(&key_send_timer,2,false);
											// 发送消息到按键发送任务
						os_event_t evt = {
							.event_id = USER_EVT_KEY_SEND,
							.src_task_id = 0,
							.param = NULL,
							.param_len = 0
						};
						os_msg_post(key_send_task_id, &evt);
				}else{
				
				   //down


				   // 检查是否是新的按键
				   if (last_pressed_key != LEFT_KEY) {
					last_pressed_key = LEFT_KEY;
					
				}

				uint32_t key_type =  LEFT_KEY;
				os_event_t evt = {
					.event_id = USER_EVT_KEY_SEND,
					.src_task_id = 0,
					.param = &key_type,
					.param_len = 0
				};
				os_msg_post(key_send_task_id, &evt);

				//    // 定义数字化仪点序列（所有状态都封装在结构体数组中）
				// 		digitizer_point_t points[] = {
				// 			// X,    Y,    tip, in_range, barrel, eraser


				// 			#if 1
				// 			{devices_config.offset_point_config[current_device_index].x_offset + 500 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{devices_config.offset_point_config[current_device_index].x_offset + 400 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{devices_config.offset_point_config[current_device_index].x_offset + 300 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{devices_config.offset_point_config[current_device_index].x_offset + 200 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{devices_config.offset_point_config[current_device_index].x_offset + 100 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{devices_config.offset_point_config[current_device_index].x_offset + 0   , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{devices_config.offset_point_config[current_device_index].x_offset + 0   , devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0}   // 点5：完全释放
		 
							
							
							
				// 			#else

				// 			//{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
				// 			{1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
				// 			{500, 1600, 0, 0, 0, 0},  // 点1：按下，在位
				// 			#endif
				// 		};
				// 		send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
						
					}
				
			}else if(devices_config.mode.mode == MUSIC_MODE){
				uint8_t raw_data[5] = {0};
				if(func_mode){

					if (!ios_devices){
					// fill_key_report(KEY_BUTTON_VOL_POWER,raw_data); 
					fill_key_report(KEY_BUTTON_Previous,raw_data); 
					hid_gatt_report_notify(0,2, raw_data, 2);

				}else{

					fill_key_report_ios(IOS_KEY_BUTTON_PREV_TRACK,raw_data); 
					hid_gatt_report_notify(0,2, raw_data, 3);
					fill_key_report_ios(0,raw_data); 
					hid_gatt_report_notify(0,2, raw_data, 3);

				}

					return 0;
				}

			}


			 }else if(button_msg->button_index == RIGHT_KEY){

				co_printf("RIGHT_KEY  Pressed\r\n");


				if(devices_config.mode.mode == REMOTE_MODE){
				//hid mouse 相对
				uint8_t raw_data[7] = {0}; // 存储最终的5字节数据

				if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){


								//x 偏移 //y 偏移
								if (!ios_devices){


									devices_config.offset_point_config[current_device_index].x_offset += 100;
							
									if (devices_config.offset_point_config[current_device_index].x_offset>4095)
									{
										devices_config.offset_point_config[current_device_index].x_offset = 4095;
									}


									digitizer_point_t points[] = {
										// X,    Y,    tip, in_range, barrel, eraser
										// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
										// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
									};
									send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
							
								}else{
									fill_hi_res_report_ios(20, 0, raw_data);
									hid_gatt_report_notify(0,4, raw_data, 3);

								}
								
					return 0;
				}


				if(ios_devices){
										// 检查是否是新的按键
										if (last_pressed_key != RIGHT_KEY) {
											// 如果按键不同，先发送reset_init_poszation
											if (connection_initialized) {
												reset_init_poszation(false);
												reset_x_y = true;
											}
											last_pressed_key = RIGHT_KEY;
										}
										
										// 启动定时器
										//os_timer_start(&key_send_timer,2,false);
											// 发送消息到按键发送任务
						os_event_t evt = {
							.event_id = USER_EVT_KEY_SEND,
							.src_task_id = 0,
							.param = NULL,
							.param_len = 0
						};
						os_msg_post(key_send_task_id, &evt);
				}else{



				   // 检查是否是新的按键
				   if (last_pressed_key != RIGHT_KEY) {
					last_pressed_key = RIGHT_KEY;
					
				}

				uint32_t key_type =  RIGHT_KEY;
				os_event_t evt = {
					.event_id = USER_EVT_KEY_SEND,
					.src_task_id = 0,
					.param = &key_type,
					.param_len = 0
				};
				os_msg_post(key_send_task_id, &evt);


				//    {
				// 			//down
				// 			digitizer_point_t points[] = {
				// 				// X,    Y,    tip, in_range, barrel, eraser

				// 				#if 1


				// 				{devices_config.offset_point_config[current_device_index].x_offset + 0 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{devices_config.offset_point_config[current_device_index].x_offset + 100 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{devices_config.offset_point_config[current_device_index].x_offset + 200 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{devices_config.offset_point_config[current_device_index].x_offset + 300 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{devices_config.offset_point_config[current_device_index].x_offset + 400 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{devices_config.offset_point_config[current_device_index].x_offset + 500   , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{devices_config.offset_point_config[current_device_index].x_offset + 500   , devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0}   // 点5：完全释放
			

				// 				#else
				// 				//{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
				// 				{1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 1500, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 1400, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 1300, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 1200, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 1100, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 1000, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 900, 1, 1, 0, 0},  // 点3：按下，在位
				// 				{1000, 800, 1, 1, 0, 0},  // 点2：按下，在位
				// 				{1000, 700, 0, 0, 0, 0},  // 点1：按下，在位
				// 				#endif
				// 			};
				// 			send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
				//    }

				}


			}else if(devices_config.mode.mode == MUSIC_MODE){
				uint8_t raw_data[5] = {0};
				if(func_mode){
						
										
					if (!ios_devices){
					//  fill_key_report(KEY_BUTTON_VOL_MENU,raw_data); 

					fill_key_report(KEY_BUTTON_Next,raw_data); 

					hid_gatt_report_notify(0,2, raw_data, 2);
					}else{

								
						fill_key_report_ios(IOS_KEY_BUTTON_NEXT_TRACK,raw_data); 
						hid_gatt_report_notify(0,2, raw_data, 3);

						fill_key_report_ios(0,raw_data); 
						hid_gatt_report_notify(0,2, raw_data, 3);
					}


					return 0;
				}

			}

			 }	 if(button_msg->button_index == OK_KEY){

				
				co_printf("OK_KEY  Pressed\r\n");

				if(devices_config.mode.mode == REMOTE_MODE){


					if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){


						if(devices_config.mode.pos_set_mode == SCROLL_POS_SETTING_MODE){
		
							devices_config.mode.pos_set_mode = NONE_SETTING_MODE;


							 devices_config_save_to_flash();

		
							printf("exit current pos setting mode %d\r\n",devices_config.mode.pos_set_mode);
						}
		
		
		
						
						if(devices_config.mode.pos_set_mode == SCROLL_POS_PICTURE_SETTING_MODE){
		
							devices_config.mode.pos_set_mode = NONE_SETTING_MODE;
		
							printf("exit current picture mode %d\r\n",devices_config.mode.pos_set_mode);
						}


						return 0;
				}else {

						if(!ios_devices){


							digitizer_point_t points[] = {
										// X,    Y,    tip, in_range, barrel, eraser
										// //{1000, 1400, 0, 1, 1, 1},  // ??4???????????????????????????
										// {500, 1600, 1, 1, 0, 0},  // ??3?????????
										// {600, 1600, 1, 1, 0, 0},  // ??3?????????
										// {700, 1600, 1, 1, 0, 0},  // ??3?????????
										// {800, 1600, 1, 1, 0, 0},  // ??3?????????
										// {900, 1600, 1, 1, 0, 0},  // ??3?????????
										// {1000, 1600, 1, 1, 0, 0},  // ??3?????????
										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // ??1?????????
										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0}   // ??5????????
									
									
									};
									send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 100);


						}else{






								// 检查是否是新的按键
								if (last_pressed_key != OK_KEY) {
									// 如果按键不同，先发送reset_init_poszation
									if (connection_initialized) {
										reset_init_poszation(false);
										reset_x_y = true;
									}
									last_pressed_key = OK_KEY;
								}

								// 启动定时器
								//os_timer_start(&key_send_timer,2,false);
									// 发送消息到按键发送任务
								os_event_t evt = {
								.event_id = USER_EVT_KEY_SEND,
								.src_task_id = 0,
								.param = NULL,
								.param_len = 0
								};
								os_msg_post(key_send_task_id, &evt);



							
						}


				}




				}else if(devices_config.mode.mode == MUSIC_MODE){

					uint8_t raw_data[5] = {0};
					if(func_mode){
						
									
						if (!ios_devices){
					//   fill_key_report(KEY_BUTTON_VOL_HOME,raw_data);
					
					fill_key_report(KEY_BUTTON_Play_Pause,raw_data); 

					hid_gatt_report_notify(0,2, raw_data, 2);
					}else{

									
						fill_key_report_ios(IOS_KEY_BUTTON_PLAY_PAUSE,raw_data); 
						hid_gatt_report_notify(0,2, raw_data, 3);
						fill_key_report_ios(0,raw_data); 
						hid_gatt_report_notify(0,2, raw_data, 3);

					}

					return 0;
				}

				}
			

			 }else if(button_msg->button_index == PICTURE_KEY){

				co_printf("PICTURE_KEY  Pressed\r\n");

				if(devices_config.mode.mode == REMOTE_MODE){



					if(button_msg->button_index == PICTURE_KEY){

							
						uint8_t raw_data[5] = {0};
						if(func_mode){
							if (!ios_devices){
								fill_key_report(KEY_BUTTON_VOL_DOWN,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 2);
							}else{

								
								fill_key_report_ios(IOS_KEY_BUTTON_VOL_DOWN,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 3);

								fill_key_report_ios(0,raw_data); 
								hid_gatt_report_notify(0,2, raw_data, 3);
							}	
							return 0;
						}

					}

				}else if(devices_config.mode.mode == MUSIC_MODE){


				}


			 }


			 

		
							
						 //co_printf("K1  Pressed\r\n");						
				}else if(button_msg->button_type == BUTTON_LONG_PRESSING){//

					uint8_t raw_data[7] = {0}; // 存储最终的5字节数据

					if(button_msg->button_index == UP_KEY ){

						printf("UP_KEY +\r\n");

						if(devices_config.mode.mode == REMOTE_MODE){
							//x 偏移 //y 偏移				
							
							if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){

							if (!ios_devices){

										devices_config.offset_point_config[current_device_index].y_offset -= 20;

										if (devices_config.offset_point_config[current_device_index].y_offset<=0)
										{
										devices_config.offset_point_config[current_device_index].y_offset = 0;
										}

									digitizer_point_t points[] = {
										// X,    Y,    tip, in_range, barrel, eraser
										// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
										// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
										{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
									};
									send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
													
							}else{
								fill_hi_res_report_ios(0, -2, raw_data);
								hid_gatt_report_notify(0,4, raw_data, 3);
							}
						}
					


						}else if(devices_config.mode.mode == MUSIC_MODE){
		
		
						}
								







					}else
					
					if(button_msg->button_index == DOWN_KEY ){
						printf("DOWN_KEY -\r\n");
								//x 偏移 //y 偏移


						if(devices_config.mode.mode == REMOTE_MODE){

					
							if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){
								if (!ios_devices){


											
									devices_config.offset_point_config[current_device_index].y_offset += 20;
									
									if (devices_config.offset_point_config[current_device_index].y_offset>4095)
									{
										devices_config.offset_point_config[current_device_index].y_offset = 4095;
									}

								digitizer_point_t points[] = {
									// X,    Y,    tip, in_range, barrel, eraser
									// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
									// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
									// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
									// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
									// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
									// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
									// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
									{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
								};
								send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
						
							}else{
								fill_hi_res_report_ios(0, 2, raw_data);
								hid_gatt_report_notify(0,4, raw_data, 3);
							}

						}

					}else if(devices_config.mode.mode == MUSIC_MODE){
		
		
					}




					}else
					
					if(button_msg->button_index == LEFT_KEY ){

						printf("LEFT_KEY -\r\n");

						if(devices_config.mode.mode == REMOTE_MODE){

	
							if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){



										//x 偏移 //y 偏移
										if (!ios_devices){
										devices_config.offset_point_config[current_device_index].x_offset  -= 20;
								
										if (devices_config.offset_point_config[current_device_index].x_offset<0)
										{
											devices_config.offset_point_config[current_device_index].x_offset = 0;
										}
										digitizer_point_t points[] = {
											// X,    Y,    tip, in_range, barrel, eraser
											// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
											// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
										};
										send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
								
									}else{
										fill_hi_res_report_ios(-2, 0, raw_data);
										hid_gatt_report_notify(0,4, raw_data, 3);

									}

								}
								}else if(devices_config.mode.mode == MUSIC_MODE){
		
		
								}
					}else
					
					if(button_msg->button_index == RIGHT_KEY ){

						printf("RIGHT_KEY +\r\n");
						if(devices_config.mode.mode == REMOTE_MODE){
								


							if(devices_config.mode.pos_set_mode != NONE_SETTING_MODE){

										//x 偏移 //y 偏移
										if (!ios_devices){


										devices_config.offset_point_config[current_device_index].x_offset += 20;
								
										if (devices_config.offset_point_config[current_device_index].x_offset>4095)
										{
											devices_config.offset_point_config[current_device_index].x_offset = 4095;
										}


										digitizer_point_t points[] = {
											// X,    Y,    tip, in_range, barrel, eraser
											// //{1000, 1400, 0, 1, 1, 1},  // 点4：释放，在位，侧键按下，橡皮擦模式
											// {500, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {600, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {700, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {800, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {900, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											// {1000, 1600, 1, 1, 0, 0},  // 点3：按下，在位
											{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点1：按下，在位
										};
										send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);
								
									}else{
										fill_hi_res_report_ios(2, 0, raw_data);
										hid_gatt_report_notify(0,4, raw_data, 3);

									}
								}

								}else if(devices_config.mode.mode == MUSIC_MODE){
		
		
								}


					}else if(button_msg->button_index == OK_KEY ){


					if(devices_config.mode.mode == REMOTE_MODE){


						
					




		




				

			

					}else if(devices_config.mode.mode == MUSIC_MODE){
		
		
					}




					}


				}
				
				
				
				
				
            }
            break;
    }

    return EVT_CONSUMED;
}

/*********************************************************************
 * @fn      audio_task_func
 *
 * @brief   Audio task function, handles audio events.
 *
 * @param   param   - OS events of audio.
 *       
 *
 * @return  int     - EVT_CONSUMED.
 */
static int audio_task_func(os_event_t *param)
{
	struct decoder_prepare_t *decoder_param = NULL;
	ADPCMContext *context = NULL;
	switch (param->event_id)
	{
		//Ƶ׼
		case DECODER_EVENT_PREPARE:			
			
			decoder_param = (struct decoder_prepare_t *)(param->param);
			decoder_env.decoder_context = os_zalloc(sizeof(ADPCMContext));
            context = (ADPCMContext *)decoder_env.decoder_context;
            context->channel = 1;
            context->block_align = decoder_param->frame_len;
            decoder_env.data_start = decoder_param->data_start;
            decoder_env.data_end = decoder_param->data_end;
            decoder_env.current_pos = decoder_param->data_start + decoder_param->start_offset;
            decoder_env.tot_data_len = decoder_param->tot_data_len;
            decoder_env.store_type = decoder_param->store_type;
            decoder_env.data_processed_len = 0;
            decoder_env.frame_len = decoder_param->frame_len;
            stop_flag = 0;

            co_printf("preparing,fram_len:%d\r\n",decoder_env.frame_len);
            co_list_init(&decoder_env.pcm_buffer_list);
            decoder_env.pcm_buffer_counter = 0;
            decoder_play_next_frame();
			decodeTASKState = DECODER_STATE_BUFFERING;
			
			break;
		//Ƶһ֡ݴ
		 case DECODER_EVENT_NEXT_FRAME:			
			decoder_play_next_frame_handler(&decodeTASKState);
		 	break;
		 
		 //Ƶֹͣ
		case DECODER_EVENT_STOP:				
		    NVIC_DisableIRQ(I2S_IRQn);

		    while(1)
		    {
		        struct co_list_hdr *element = co_list_pop_front(&decoder_env.pcm_buffer_list);
		        if(element == NULL)
		            break;
		        os_free((void *)element);
		    }

		    if(decoder_env.decoder_context != NULL)
		    {
		        os_free((void *)decoder_env.decoder_context);
		        decoder_env.decoder_context = NULL;
		    }
			decodeTASKState = DECODER_STATE_IDLE;
		    speaker_stop_hw();
		    decoder_end_func();
		    decoder_hold_flag = false;
			break;
	}
    return EVT_CONSUMED;
}


/*********************************************************************
 * @fn      user_task_init
 *
 * @brief   Application task initialization, create all application tasks here.
 *
 * @param   None. 
 *       
 *
 * @return  None.
 */
void user_task_init(void)
{
    user_task_id = os_task_create(user_task_func);
	  //audio_task_id = os_task_create(audio_task_func);//Ƶ

	// 创建按键发送任务
	key_send_task_id = os_task_create(key_send_task_func);
	
	// 初始化定时器
	os_timer_init(&key_send_timer,key_send_timer_timeout_handler, NULL);
	os_timer_init(&data_consume_timer, data_consume_timer_timeout_handler, NULL);
	
	// 初始化数据环形缓冲区 - 使用 y_ringbuf
	data_ringbuf = y_ringbuf_create(MAX_DATA_PACKETS * DATA_PACKET_SIZE);
	if (data_ringbuf == NULL) {
		co_printf("Failed to create data ringbuf\r\n");
	}
}




// HID Touch 封装函数

void hid_touch_send(uint16_t x, uint16_t y, uint8_t down)
{
    uint8_t touch_report[7];
    touch_report[0] = 0x04; // Report ID
    touch_report[1] = down ? 0x01 : 0x00; // 状态
    touch_report[2] = 0x01; // Contact ID
    touch_report[3] = x & 0xFF;
    touch_report[4] = (x >> 8) & 0xFF;
    touch_report[5] = y & 0xFF;
    touch_report[6] = (y >> 8) & 0xFF;
    uint8_t conidx = 0;
    hid_gatt_report_notify(conidx, 4, touch_report, 7);
}




// 新增按键发送任务处理函数
static int key_send_task_func(os_event_t *param)
{
	//printf("%s\r\n",__FUNCTION__);
    switch(param->event_id)
    {
        case USER_EVT_KEY_SEND:
            {
                #if 0
            
                #else
                // 新的ringbuffer方式处理按键发送逻辑
                uint8_t raw_data[10] = {0}; // 存储最终的3字节数据
										uint8_t finger_data[7] = {0};


				int16_t x_offset = 0, y_offset = 0; // 根据按键动态设置的偏移量

				// 根据last_pressed_key动态设置初始位置偏移
				switch(last_pressed_key) {
					case UP_KEY:
						x_offset = 60;
						y_offset = 180/*150 - 40*3*//*100 + 150*/; // 向下偏移
						break;
					case DOWN_KEY:
						x_offset = 60;
						y_offset = 116/*150 + 40*3*/; // 向上偏移
						break;
					case LEFT_KEY:
						x_offset = 80; // 向左偏移
						y_offset = 100;
						break;
					case RIGHT_KEY:
						x_offset = 80; // 向右偏移
						y_offset = 100;
						break;
					default:
						x_offset = 60;
						y_offset = 116;
						break;
				}

				


                // 根据上次按下的按键执行不同的操作
    switch(last_pressed_key) {
        
		case  UP_KEY:


if(!ios_devices){




				// 发送序列，每个点之间延时20个单位（约5ms）
					//hid touch 
					// 定义数字化仪点序列（所有状态都封装在结构体数组中）
					digitizer_point_t points[] = {
					// X,    Y,    tip, in_range, barrel, eraser
	

					{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset - 200  , 1, 1, 0, 0},  // 点1：按下，在位
					// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 100, 1, 1, 0, 0},  // 点2：按下，在位
					// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 200, 1, 1, 0, 0},  // 点3：按下，在位
					{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 200, 1, 1, 0, 0},  // 点3：按下，在位
					// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 400, 1, 1, 0, 0},  // 点3：按下，在位
					// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 500, 1, 1, 0, 0},  // 点3：按下，在位
					{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 400, 1, 1, 0, 0},  // 点3：按下，在位
					// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 700, 1, 1, 0, 0},  // 点3：按下，在位
					// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 800, 1, 1, 0, 0},  // 点3：按下，在位
					{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 800, 1, 1, 0, 0},  // 点3：按下，在位
					{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 800, 0, 0, 0, 0},   // 点5：完全释放
					//{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 0  , 0, 0, 0, 0},  // 点1：按下，在位

			
					};
			       //send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);	

					for(int i = 0;i<sizeof(points)/sizeof(points[0]);i++){

						 fill_digitizer_report_android(&points[i], 1,raw_data);
						 add_scroll_report_to_buffer(5, raw_data,5);
					}



}else{

					fill_mouse_report_ios(0, 0, 0, raw_data);
					add_mouse_report_to_buffer(3, raw_data, 3);
					fill_mouse_report_ios(0, 0, 0, raw_data);
					add_mouse_report_to_buffer(3, raw_data, 3);
                        //press 
						for(int i = 0;i < 3;i++){
                        fill_mouse_report_ios(MOUSE_BUTTON_KEY_UP, -100, 0, raw_data);
                        add_mouse_report_to_buffer(3, raw_data, 3);
						}

					// // 发送初始位置重置序列到缓冲区
					// fill_hi_res_report_ios(-2047,-2047,raw_data);
					// add_hi_res_report_to_buffer(4, raw_data, 3);

					// // 根据按键动态设置初始位置
					// fill_hi_res_report_ios(x_offset, y_offset, raw_data);
					// add_hi_res_report_to_buffer(4, raw_data, 3);




					for(int i  = 0;i<3;i++){

						fill_finger_report_ios(0x06, 1904, 1904 - i*20,
							true, 1,
							finger_data);
						add_finger_report_to_buffer(0,finger_data,7);
					}
			
					fill_finger_report_ios(0x06, 0, 0,
						false, 0,
						finger_data);
					add_finger_report_to_buffer(0,finger_data,7);
	}

#if 0
				for(int i = 0;i < 3;i++){
					fill_hi_res_report_ios(0,-10,raw_data);
					add_hi_res_report_to_buffer(4, raw_data, 3);
				}

				//press release
				fill_mouse_report_ios(0, 0, 0, raw_data);
				add_mouse_report_to_buffer(3, raw_data, 3);

				for(int i = 0;i < 3;i++){
					fill_hi_res_report_ios(0,10,raw_data);
					add_hi_res_report_to_buffer(4, raw_data, 3);
				}
#endif								

					
                        break;

        case DOWN_KEY:


		
		if(!ios_devices){




	// 发送序列，每个点之间延时20个单位（约5ms）
		//hid touch 
		// 定义数字化仪点序列（所有状态都封装在结构体数组中）
		digitizer_point_t points[] = {
		// X,    Y,    tip, in_range, barrel, eraser

		{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 200  , 1, 1, 0, 0},  // 点3：按下，在位

		{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset -200 , 1, 1, 0, 0},  // 点1：按下，在位
		// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 800, 1, 1, 0, 0},  // 点2：按下，在位
		// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 700, 1, 1, 0, 0},  // 点3：按下，在位
		{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset - 400, 1, 1, 0, 0},  // 点3：按下，在位
		// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 500, 1, 1, 0, 0},  // 点3：按下，在位
		// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 400, 1, 1, 0, 0},  // 点3：按下，在位
		{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset - 800, 1, 1, 0, 0},  // 点3：按下，在位
		{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset - 800, 0, 0, 0, 0},  // 点3：按下，在位

		// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 200, 1, 1, 0, 0},  // 点3：按下，在位
		// {devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 100, 1, 1, 0, 0},  // 点3：按下，在位
		//{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 0, 0, 0, 0, 0},   // 点5：完全释放
		//{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset + 1300 , 0, 0, 0, 0},  // 点1：按下，在位



		};
	   //send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);	

		for(int i = 0;i<sizeof(points)/sizeof(points[0]);i++){

			 fill_digitizer_report_android(&points[i], 1,raw_data);
			 add_scroll_report_to_buffer(5, raw_data,5);
		}



}else{
					fill_mouse_report_ios(0, 0, 0, raw_data);
					add_mouse_report_to_buffer(3, raw_data, 3);
					fill_mouse_report_ios(0, 0, 0, raw_data);
					add_mouse_report_to_buffer(3, raw_data, 3);


					
                        // //press 
                        // fill_mouse_report_ios(MOUSE_BUTTON_KEY_DOWN, 0, 0, raw_data);
                        // add_mouse_report_to_buffer(3, raw_data, 3);


						for(int i = 0;i < 3;i++){
							fill_mouse_report_ios(MOUSE_BUTTON_KEY_DOWN, 100, 0, raw_data);
							add_mouse_report_to_buffer(3, raw_data, 3);
							}











// // 发送初始位置重置序列到缓冲区
// fill_hi_res_report_ios(-2047,-2047,raw_data);
// add_hi_res_report_to_buffer(4, raw_data, 3);

// // 根据按键动态设置初始位置
// fill_hi_res_report_ios(x_offset, y_offset, raw_data);
// add_hi_res_report_to_buffer(4, raw_data, 3);




#if 0

	for(int i = 0;i < 3;i++){
		fill_hi_res_report_ios(0,10,raw_data);
		add_hi_res_report_to_buffer(4, raw_data, 3);
	}

	//press release
	fill_mouse_report_ios(0, 0, 0, raw_data);
	add_mouse_report_to_buffer(3, raw_data, 3);

	for(int i = 0;i < 3;i++){
		fill_hi_res_report_ios(0,-10,raw_data);
		add_hi_res_report_to_buffer(4, raw_data, 3);
	}


#endif

	


					for(int i  = 0;i<3;i++){

						fill_finger_report_ios(0x06, 1904, 1904 + i*20,
							true, 1,
							finger_data);
						add_finger_report_to_buffer(0,finger_data,7);
					}
			
					fill_finger_report_ios(0x06, 0, 0,
						false, 0,
						finger_data);
					add_finger_report_to_buffer(0,finger_data,7);


					}


                        break;

                    case LEFT_KEY:


					if(!ios_devices){




						// 发送序列，每个点之间延时20个单位（约5ms）
							//hid touch 
							// 定义数字化仪点序列（所有状态都封装在结构体数组中）
							digitizer_point_t points[] = {
							// X,    Y,    tip, in_range, barrel, eraser
			
		
							{devices_config.offset_point_config[current_device_index].x_offset + 800 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
							{devices_config.offset_point_config[current_device_index].x_offset + 400 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
							// {devices_config.offset_point_config[current_device_index].x_offset + 300 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
							// {devices_config.offset_point_config[current_device_index].x_offset + 200 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
							// {devices_config.offset_point_config[current_device_index].x_offset + 100 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
							{devices_config.offset_point_config[current_device_index].x_offset - 200   , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
							{devices_config.offset_point_config[current_device_index].x_offset  -200   , devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0},   // 点5：完全释放
		 
							{devices_config.offset_point_config[current_device_index].x_offset + 800 , devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0},  // 点3：按下，在位

					
							};
						   //send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);	
		
							for(int i = 0;i<sizeof(points)/sizeof(points[0]);i++){
		
								 fill_digitizer_report_android(&points[i], 1,raw_data);
								 add_scroll_report_to_buffer(5, raw_data,5);
							}
		
		
		
		}else{
					fill_mouse_report_ios(0, 0, 0, raw_data);
					add_mouse_report_to_buffer(3, raw_data, 3);
					fill_mouse_report_ios(0, 0, 0, raw_data);
					add_mouse_report_to_buffer(3, raw_data, 3);
                   


					for(int i = 0;i < 3;i++){
                        fill_mouse_report_ios(MOUSE_BUTTON_KEY_LEFT, 0, -50, raw_data);
                        add_mouse_report_to_buffer(3, raw_data, 3);
					}


						#if 0
                        for(int i = 0;i < 3;i++){
                            fill_hi_res_report_ios(-20,0,raw_data);
                            add_hi_res_report_to_buffer(4, raw_data, 3);
                        }

                        //press release
                        fill_mouse_report_ios(0, 0, 0, raw_data);
                        add_mouse_report_to_buffer(3, raw_data, 3);



						for(int i = 0;i < 3;i++){
                            fill_hi_res_report_ios(20,0,raw_data);
                            add_hi_res_report_to_buffer(4, raw_data, 3);
                        }
							#else
							for(int i  = 0;i<3;i++){

								fill_finger_report_ios(0x06, 1904  + i*20, 1904 ,
									true, 1,
									finger_data);
								add_finger_report_to_buffer(0,finger_data,7);
							}
					
							fill_finger_report_ios(0x06, 0, 0,
								false, 0,
								finger_data);
							add_finger_report_to_buffer(0,finger_data,7);
		


							#endif

		}
                        break;

                    case RIGHT_KEY:
                        //press 


						if(!ios_devices){




							// 发送序列，每个点之间延时20个单位（约5ms）
								//hid touch 
								// 定义数字化仪点序列（所有状态都封装在结构体数组中）
								digitizer_point_t points[] = {
								// X,    Y,    tip, in_range, barrel, eraser
				
			
								{devices_config.offset_point_config[current_device_index].x_offset - 200 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
								// {devices_config.offset_point_config[current_device_index].x_offset + 100 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
								// {devices_config.offset_point_config[current_device_index].x_offset + 200 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
								// {devices_config.offset_point_config[current_device_index].x_offset + 300 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
								{devices_config.offset_point_config[current_device_index].x_offset + 400 , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
								{devices_config.offset_point_config[current_device_index].x_offset + 800   , devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // 点3：按下，在位
								{devices_config.offset_point_config[current_device_index].x_offset + 800   , devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0},   // 点5：完全释放
								{devices_config.offset_point_config[current_device_index].x_offset - 200   , devices_config.offset_point_config[current_device_index].y_offset, 0, 0, 0, 0}   // 点5：完全释放

						
								};
							   //send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);	
			
								for(int i = 0;i<sizeof(points)/sizeof(points[0]);i++){
			
									 fill_digitizer_report_android(&points[i], 1,raw_data);
									 add_scroll_report_to_buffer(5, raw_data,5);
								}
			
			
			
			}else{
						fill_mouse_report_ios(0, 0, 0, raw_data);
						add_mouse_report_to_buffer(3, raw_data, 3);
						fill_mouse_report_ios(0, 0, 0, raw_data);
						add_mouse_report_to_buffer(3, raw_data, 3);


						for(int i = 0;i < 3;i++){
                        fill_mouse_report_ios(MOUSE_BUTTON_KEY_RIGHT, 0, 50, raw_data);
                        add_mouse_report_to_buffer(3, raw_data, 3);
						}
						#if 0
                        for(int i = 0;i < 3;i++){
                            fill_hi_res_report_ios(20,0,raw_data);
                            add_hi_res_report_to_buffer(4, raw_data, 3);
                        }

                        //press release
                        fill_mouse_report_ios(0, 0, 0, raw_data);
                        add_mouse_report_to_buffer(3, raw_data, 3);

						
                        for(int i = 0;i < 3;i++){
                            fill_hi_res_report_ios(-20,0,raw_data);
                            add_hi_res_report_to_buffer(4, raw_data, 3);
                        }
						#else
						for(int i  = 0;i<3;i++){

							fill_finger_report_ios(0x06, 1904 + i*20, 1904 ,
								true, 1,
								finger_data);
							add_finger_report_to_buffer(0,finger_data,7);
						}
				
						fill_finger_report_ios(0x06, 0, 0,
							false, 0,
							finger_data);
						add_finger_report_to_buffer(0,finger_data,7);
	


						#endif

						}
                        break;


						case OK_KEY:

						uint8_t conidx = 0; // 连接索引
						uint8_t raw_data[5] = {0};
			


						if(!ios_devices){
						
							// 打印原始数据
					
							
							for(int i = 0;i<2;i++){

							raw_data[0] = 0x07;
							raw_data[1] = (uint8_t)(devices_config.offset_point_config[current_device_index].x_offset & 0xFF);
							raw_data[2] = (uint8_t)(((devices_config.offset_point_config[current_device_index].x_offset)>>8)& 0xFF);
							raw_data[3] = (uint8_t)(devices_config.offset_point_config[current_device_index].y_offset& 0xFF);
							raw_data[4] = (uint8_t)(((devices_config.offset_point_config[current_device_index].y_offset)>>8)& 0xFF);
							// 发送报告

							add_double_report_to_buffer(5,raw_data, 5);
							// hid_gatt_report_notify(conidx, 5, raw_data, 5);
							// co_delay_100us(50);
							// printf("raw_data: ");
							// for(int j = 0; j < 5; j++) {
							// 	printf("%02X ", raw_data[j]);
							// }
							// printf("\r\n");


							raw_data[0] = 0x04;
							raw_data[1] = (uint8_t)(devices_config.offset_point_config[current_device_index].x_offset & 0xFF);
							raw_data[2] = (uint8_t)(((devices_config.offset_point_config[current_device_index].x_offset)>>8)& 0xFF);
							raw_data[3] = (uint8_t)(devices_config.offset_point_config[current_device_index].y_offset& 0xFF);
							raw_data[4] = (uint8_t)(((devices_config.offset_point_config[current_device_index].y_offset)>>8)& 0xFF);
							// 发送报告
							// hid_gatt_report_notify(conidx, 5, raw_data, 5);
							// co_delay_100us(100);
							//co_delay_100us(delay_connect_send * 2);
							add_double_report_to_buffer(5,raw_data, 5);
							// printf("raw_data: ");
							// for(int j = 0; j < 5; j++) {
							// 	printf("%02X ", raw_data[j]);
							// }
							// printf("\r\n");

						}
					}else{



						// for(int i  = 0;i<2;i++){

						// 	fill_finger_report_ios(0x06, 0, 0 ,
						// 		true, 1,
						// 		finger_data);
						// 	add_finger_report_to_buffer(0,finger_data,7);

						// 	fill_finger_report_ios(0x06, 0, 0,
						// 		false, 0,
						// 		finger_data);
						// 	add_finger_report_to_buffer(0,finger_data,7);
						// }


						uint8_t raw_data[3] = {0};
						for(int i = 0;i < 1;i++){
							fill_mouse_report_ios(MOUSE_BUTTON_LEFT, 0, 0, raw_data);
							add_mouse_report_to_buffer(3, raw_data, 3);
							//hid_gatt_report_notify(0,3, raw_data, 3);


							fill_mouse_report_ios(0, 0, 0, raw_data);
							add_mouse_report_to_buffer(3, raw_data, 3);
							//hid_gatt_report_notify(0,3, raw_data, 3);

							}
				
						
							// fill_mouse_report_ios(0, 0, 0, raw_data);
							// add_mouse_report_to_buffer(3, raw_data, 3);
							// fill_mouse_report_ios(0, 0, 0, raw_data);
							// add_mouse_report_to_buffer(3, raw_data, 3);
							//press 
							// for(int i = 0;i < 2;i++){
							// fill_mouse_report_ios(MOUSE_BUTTON_LEFT, 0, 0, raw_data);
							// add_mouse_report_to_buffer(3, raw_data, 3);


							// fill_mouse_report_ios(0, 0, 0, raw_data);
							// add_mouse_report_to_buffer(3, raw_data, 3);
							// }
					}




							

						// digitizer_point_t points[] = {
			
						// 				{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // ??1?????????
						// 				{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 1, 0, 0},   // ??5????????
						// 				{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 1, 1, 0, 0},  // ??1?????????
						// 				{devices_config.offset_point_config[current_device_index].x_offset, devices_config.offset_point_config[current_device_index].y_offset, 0, 1, 0, 0},   // ??5????????

									
						// 			};
						// 			send_digitizer_sequence(points, sizeof(points)/sizeof(points[0]), 50);




	// 1. ??????????
//	output_buffer[0] = (tip_switch & 0x01) |
//	((in_range & 0x01) << 1) |
//	((barrel_switch & 0x01) << 5) |
//	((eraser & 0x01) << 6);

//	(tip_switch & 0x01)?output_buffer[0]|=(0x01 << 2): output_buffer[0]&(~((0x01 << 2)));

//	// 2. ??????? (????????????????)
//	output_buffer[1] = (uint8_t)(x & 0xFF);       // ?????
//	output_buffer[2] = (uint8_t)((x >> 8) & 0xFF); // ?????

//	// 3. ??????? (????????????????)
//	output_buffer[3] = (uint8_t)(y & 0xFF);       // ?????
//	output_buffer[4] = (uint8_t)((y >> 8) & 0xFF); // ?????



//									fill_mouse_report_ios(0, 0, 0, raw_data);
//									add_mouse_report_to_buffer(3, raw_data, 3);
//										//press 
//										for(int i = 0;i < 2;i++){
//										fill_mouse_report_ios(MOUSE_BUTTON_LEFT, 0, 0, raw_data);
//										add_mouse_report_to_buffer(3, raw_data, 3);
//										fill_mouse_report_ios(0, 0, 0, raw_data);
//										add_mouse_report_to_buffer(3, raw_data, 3);
//										}




						break;

                    default:
                        break;
                }
                
                // 启动数据消耗定时器，30ms消耗一帧数据delay_connect_send * 1/*30*/

				if(last_pressed_key	!=	OK_KEY){
               		 os_timer_start(&data_consume_timer, delay_connect_send * 1, true);
				}else{
					 os_timer_start(&data_consume_timer, delay_connect_send * 4, true);
				}
                #endif
            }
            break;
        default:
            break;
    }
    return EVT_CONSUMED;
}

void key_send_timer_timeout_handler(void *p){

	#if 1




	
	// 发送消息到按键发送任务
	os_event_t evt = {
		.event_id = USER_EVT_KEY_SEND,
		.src_task_id = 0,
		.param = NULL,
		.param_len = 0
	};
	os_msg_post(key_send_task_id, &evt);


	
	#else


	#endif
}


void  reset_init_poszation(bool start_timer){
	#if 0
	uint8_t raw_data[3] = {0}; // 存储最终的3字节数据
	int16_t x_offset = 0, y_offset = 0; // 根据按键动态设置的偏移量

	// 根据last_pressed_key动态设置初始位置偏移
	switch(last_pressed_key) {
		case UP_KEY:

		x_offset = 60;
		y_offset = 308/*100 + 150*/; // 向下偏移

			break;
		case DOWN_KEY:
		x_offset = 60;
		y_offset = 116; // 向上偏移
			break;
		case LEFT_KEY:
			x_offset = 80; // 向左偏移
			y_offset = 100;
			break;
		case RIGHT_KEY:
			x_offset = 80+150; // 向右偏移
			y_offset = 100;
			break;
		default:
			x_offset = 60;
			y_offset = 116;
			break;
	}

	// 发送初始位置重置序列
	fill_hi_res_report_ios(-2047,-2047,raw_data);
	raw_data[0] = 0x01;
	raw_data[1] = 0x18;
	raw_data[2] = 0x80;
	hid_gatt_report_notify(0, /*(id)*/ 4, raw_data, 3); // 发送
	printf("time %d,%d\r\n",delay_connect_send,delay_connect_send*20);
	co_delay_100us(delay_connect_send*20); // 具体延时API视系统而定

	fill_hi_res_report_ios(-2047,-2047,raw_data);
	raw_data[0] = 0x01;
	raw_data[1] = 0x18;
	raw_data[2] = 0x80;
	hid_gatt_report_notify(0, /*(id)*/ 4, raw_data, 3); // 发送
	co_delay_100us(delay_connect_send*20); // 具体延时API视系统而定

	fill_hi_res_report_ios(-2047,-2047,raw_data);
	raw_data[0] = 0x00;
	raw_data[1] = 0x10;
	raw_data[2] = 0x80;
	hid_gatt_report_notify(0, /*(id)*/ 4, raw_data, 3); // 发送
	co_delay_100us(delay_connect_send*20); // 具体延时API视系统而定

	//press release
	// fill_mouse_report_ios(1, 0, 0, raw_data);
	// hid_gatt_report_notify(0, /*(id)*/ 3, raw_data, 3); // 发送
	// co_delay_100us(delay_connect_send*20); // 具体延时API视系统而定

	// 根据按键动态设置初始位置
	fill_hi_res_report_ios(x_offset, y_offset, raw_data);
	hid_gatt_report_notify(0, /*(id)*/ 4, raw_data, 3); // 发送
	co_delay_100us(delay_connect_send*20); // 具体延时API视系统而定

	//press release
	fill_mouse_report_ios(0, 0, 0, raw_data);
	hid_gatt_report_notify(0, /*(id)*/ 3, raw_data, 3); // 发送
	co_delay_100us(delay_connect_send*20); // 具体延时API视系统而定

	//press release
	fill_mouse_report_ios(0, 0, 0, raw_data);
	hid_gatt_report_notify(0, /*(id)*/ 3, raw_data, 3); // 发送
	co_delay_100us(delay_connect_send*20); // 具体延时API视系统而定
	#else
	// 新的ringbuffer方式实现
	uint8_t raw_data[3] = {0}; // 存储最终的3字节数据
	int16_t x_offset = 0, y_offset = 0; // 根据按键动态设置的偏移量

	// 根据last_pressed_key动态设置初始位置偏移
	switch(last_pressed_key) {
		case UP_KEY:
						x_offset = 60;
						y_offset = 180/*150 - 40*3*//*100 + 150*/; // 向下偏移
						break;
					case DOWN_KEY:
						x_offset = 60;
						y_offset = 116/*150 + 40*3*/; // 向上偏移
						break;
		case LEFT_KEY:
			x_offset = 80; // 向左偏移
			y_offset = 100;
			break;
		case RIGHT_KEY:
			x_offset = 80; // 向右偏移
			y_offset = 100;
			break;
		default:
			x_offset = 60;
			y_offset = 116;
			break;
	}
	#if 0
	// 发送初始位置重置序列到缓冲区
	fill_hi_res_report_ios(-2047,-2047,raw_data);
	raw_data[0] = 0x01;
	raw_data[1] = 0x18;
	raw_data[2] = 0x80;
	add_hi_res_report_to_buffer(4, raw_data, 3);

	fill_hi_res_report_ios(-2047,-2047,raw_data);
	raw_data[0] = 0x01;
	raw_data[1] = 0x18;
	raw_data[2] = 0x80;
	add_hi_res_report_to_buffer(4, raw_data, 3);

	fill_hi_res_report_ios(-2047,-2047,raw_data);
	raw_data[0] = 0x00;
	raw_data[1] = 0x10;
	raw_data[2] = 0x80;
	add_hi_res_report_to_buffer(4, raw_data, 3);




		// 根据按键动态设置初始位置
	fill_hi_res_report_ios(x_offset, y_offset, raw_data);
	add_hi_res_report_to_buffer(4, raw_data, 3);

	#else



	uint8_t finger_data[7] = {0};
	for(int i  = 0;i<3;i++){

		fill_finger_report_ios(0x06, 0, 0,
			true, 1,
			finger_data);
		add_finger_report_to_buffer(0,finger_data,7);
	}


	fill_finger_report_ios(0x06, 0, 0,
		false, 0,
		finger_data);
	add_finger_report_to_buffer(0,finger_data,7);
	#endif


	//press release
	fill_mouse_report_ios(0, 0, 0, raw_data);
	add_mouse_report_to_buffer(3, raw_data, 3);

	//press release
	fill_mouse_report_ios(0, 0, 0, raw_data);
	add_mouse_report_to_buffer(3, raw_data, 3);

	// 根据参数决定是否启动数据消耗定时器
	if (start_timer) {
		os_timer_start(&data_consume_timer, delay_connect_send * 2/*30*/, true);
	}
	#endif
}

// 数据包管理函数实现
void add_mouse_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len)
{
    if (data_ringbuf == NULL) {
        return;
    }
    
    data_packet_t packet;
    packet.type = DATA_TYPE_MOUSE_REPORT;
    packet.report_id = report_id;
    packet.data_len = len;
    memcpy(packet.data, data, len);
    
    y_ringbuf_write(data_ringbuf, (uint8_t*)&packet, DATA_PACKET_SIZE);
}

void add_hi_res_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len)
{
    if (data_ringbuf == NULL) {
        return;
    }
    
    data_packet_t packet;
    packet.type = DATA_TYPE_HI_RES_REPORT;
    packet.report_id = report_id;
    packet.data_len = len;
    memcpy(packet.data, data, len);
    
    y_ringbuf_write(data_ringbuf, (uint8_t*)&packet, DATA_PACKET_SIZE);
}

void add_finger_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len)
{
    if (data_ringbuf == NULL) {
        return;
    }
    
    data_packet_t packet;
    packet.type = DATA_TYPE_FINGGER_REPORT;
    packet.report_id = report_id;
    packet.data_len = len;
    memcpy(packet.data, data, len);
    
    y_ringbuf_write(data_ringbuf, (uint8_t*)&packet, DATA_PACKET_SIZE);
}



void add_double_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len)
{
    if (data_ringbuf == NULL) {
        return;
    }
    
    data_packet_t packet;
    packet.type = DATA_TYPE_DOUBLE_CLICK_REPORT;
    packet.report_id = report_id;
    packet.data_len = len;
    memcpy(packet.data, data, len);
    
    y_ringbuf_write(data_ringbuf, (uint8_t*)&packet, DATA_PACKET_SIZE);
}






// 数据包管理函数实现
void add_scroll_report_to_buffer(uint8_t report_id, uint8_t *data, uint8_t len)
{
    if (data_ringbuf == NULL) {
        return;
    }
    
    data_packet_t packet;
    packet.type = DATA_TYPE_SCROLL_REPORT;
    packet.report_id = report_id;
    packet.data_len = len;
    memcpy(packet.data, data, len);
    
    y_ringbuf_write(data_ringbuf, (uint8_t*)&packet, DATA_PACKET_SIZE);
}




void data_consume_timer_timeout_handler(void *p)
{
    if (data_ringbuf == NULL) {
        os_timer_stop(&data_consume_timer);
        return;
    }
    
    // 检查是否有数据可读
    if (y_ringbuf_is_empty(data_ringbuf)) {
        // 没有更多数据，停止定时器
        os_timer_stop(&data_consume_timer);
        return;
    }
    
    // 读取一个数据包
    data_packet_t packet;
    uint16_t read_size = y_ringbuf_read_clear(data_ringbuf, (uint8_t*)&packet, DATA_PACKET_SIZE);
    
    if (read_size == DATA_PACKET_SIZE) {
        // 成功读取数据包，发送数据
        switch(packet.type)
        {
            case DATA_TYPE_MOUSE_REPORT:
                hid_gatt_report_notify(0, packet.report_id, packet.data, packet.data_len);
                break;
                
            case DATA_TYPE_HI_RES_REPORT:
                hid_gatt_report_notify(0, packet.report_id, packet.data, packet.data_len);
                break;
                
				case DATA_TYPE_FINGGER_REPORT:
                hid_gatt_report_notify(0, packet.report_id, packet.data, packet.data_len);
                break;


				case DATA_TYPE_DOUBLE_CLICK_REPORT:
                hid_gatt_report_notify(0, packet.report_id, packet.data, packet.data_len);
                break;

				case DATA_TYPE_SCROLL_REPORT:
                hid_gatt_report_notify(0, packet.report_id, packet.data, packet.data_len);
                break;

				


            default:
                break;
        }
        
        // 添加延时，确保每个包之间有足够的时间间隔
        co_delay_100us(delay_connect_send * 2);
    }
}

// 清理函数，用于销毁环形缓冲区
void cleanup_data_ringbuf(void)
{
    if (data_ringbuf != NULL) {
        y_ringbuf_destroy(data_ringbuf);
        data_ringbuf = NULL;
    }
}

/*********************************************************************
 * 设备配置管理函数实现
 *********************************************************************/

/**
 * @brief 初始化设备配置管理
 */
void devices_config_init(void)
{
    if (!devices_config_initialized) {
        // 从flash加载设备配置
        devices_config_load_from_flash();
        devices_config_initialized = true;
        co_printf("Device configuration management initialized, device count: %d\r\n", devices_config.DEVICE_NUM);
    }
}

void devices_config_Reinitialized(){

	        devices_config_initialized = false;

}

/**
 * @brief 保存设备名称到设备配置中
 * @param device_name 设备名称
 * @param name_len 设备名称长度
 * @return true: 保存成功, false: 保存失败
 */
bool devices_config_save_device_name(const uint8_t *device_name, uint16_t name_len)
{
    if (device_name == NULL || name_len == 0 || name_len > 47) {
        co_printf("Device name parameter invalid\r\n");
        return false;
    }
    
    // 检查设备是否已存在
    if (devices_config_find_device(device_name, name_len)) {
        co_printf("Device already exists, no need to save again\r\n");
        return true;
    }
    
    // 检查设备数量是否已达到最大值
    if (devices_config.DEVICE_NUM >= 8) {
        co_printf("Device count reached maximum 8, cannot add new device\r\n");
        return false;
    }
    
    // 保存设备名称到下一个可用位置
    uint8_t index = devices_config.DEVICE_NUM;
    memset(devices_config.offset_point_config[index].dev_name, 0, 48);
    memcpy(devices_config.offset_point_config[index].dev_name, device_name, name_len);
    devices_config.offset_point_config[index].dev_name[name_len] = '\0';
    
    // 初始化该设备的其他配置
    devices_config.offset_point_config[index].report_mode = false;
    devices_config.offset_point_config[index].x_offset = 0;
    devices_config.offset_point_config[index].y_offset = 0;
    devices_config.offset_point_config[index].picture_x_offset = 0;
    devices_config.offset_point_config[index].picture_y_offset = 0;

    devices_config.mode.mode = REMOTE_MODE;
    devices_config.mode.pos_set_mode = NONE_SETTING_MODE;
    
    // 设备数量加1
    devices_config.DEVICE_NUM++;
    
    // 保存到flash
    devices_config_save_to_flash();
    
    co_printf("Device name saved successfully: %s, current device count: %d\r\n", 
              devices_config.offset_point_config[index].dev_name, devices_config.DEVICE_NUM);
    
    return true;
}

/**
 * @brief 查找设备是否已存在
 * @param device_name 设备名称
 * @param name_len 设备名称长度
 * @return true: 设备存在, false: 设备不存在
 */
bool devices_config_find_device(const uint8_t *device_name, uint16_t name_len)
{
    if (device_name == NULL || name_len == 0) {
        return false;
    }
    
    for (uint8_t i = 0; i < devices_config.DEVICE_NUM; i++) {
        if (strlen((char*)devices_config.offset_point_config[i].dev_name) == name_len &&
            memcmp(devices_config.offset_point_config[i].dev_name, device_name, name_len) == 0) {
            // 设置当前设备名称
            memset(current_device_name, 0, sizeof(current_device_name));
            memcpy(current_device_name, device_name, name_len);
            current_device_name[name_len] = '\0';
            return true;
        }
    }
    
    return false;
}

/**
 * @brief 更新设备名称
 * @param old_name 旧设备名称
 * @param old_name_len 旧设备名称长度
 * @param new_name 新设备名称
 * @param new_name_len 新设备名称长度
 * @return true: 更新成功, false: 更新失败
 */
bool devices_config_update_device_name(const uint8_t *old_name, uint16_t old_name_len, 
                                      const uint8_t *new_name, uint16_t new_name_len)
{
    if (old_name == NULL || new_name == NULL || 
        old_name_len == 0 || new_name_len == 0 || new_name_len > 47) {
        co_printf("Device name parameter invalid\r\n");
        return false;
    }
    
    // 查找设备
    for (uint8_t i = 0; i < devices_config.DEVICE_NUM; i++) {
        if (strlen((char*)devices_config.offset_point_config[i].dev_name) == old_name_len &&
            memcmp(devices_config.offset_point_config[i].dev_name, old_name, old_name_len) == 0) {
            
            // 更新设备名称
            memset(devices_config.offset_point_config[i].dev_name, 0, 48);
            memcpy(devices_config.offset_point_config[i].dev_name, new_name, new_name_len);
            devices_config.offset_point_config[i].dev_name[new_name_len] = '\0';
            
            // 保存到flash
            devices_config_save_to_flash();
            
            co_printf("Device name updated successfully: %s -> %s\r\n", old_name, new_name);
            return true;
        }
    }
    
    co_printf("Device not found for update: %s\r\n", old_name);
    return false;
}

/**
 * @brief 获取当前连接的设备名称
 * @param device_name 输出参数：设备名称缓冲区
 * @param name_len 输出参数：设备名称长度
 * @return true: 获取成功, false: 获取失败
 */
bool devices_config_get_current_device_name(uint8_t *device_name, uint16_t *name_len)
{
    if (device_name == NULL || name_len == NULL) {
        return false;
    }
    
    uint16_t len = strlen(current_device_name);
    if (len > 0) {
        memcpy(device_name, current_device_name, len);
        *name_len = len;
        return true;
    }
    
    return false;
}

/**
 * @brief 保存设备配置到flash
 */
void devices_config_save_to_flash(void)
{
    // 擦除flash扇区
    flash_erase(DEVICES_CONFIG_SAVE_ADDR, 0x1000);
    
    // 写入设备配置数据
    flash_write(DEVICES_CONFIG_SAVE_ADDR, sizeof(devices_config_t), (uint8_t*)&devices_config);
    
    co_printf("Device configuration saved to flash, address: 0x%X\r\n", DEVICES_CONFIG_SAVE_ADDR);
}

/**
 * @brief 从flash加载设备配置
 */
void devices_config_load_from_flash(void)
{
    // 从flash读取设备配置数据
    flash_read(DEVICES_CONFIG_SAVE_ADDR, sizeof(devices_config_t), (uint8_t*)&devices_config);
    
    // 验证数据有效性
    if (devices_config.DEVICE_NUM > 8) {
        co_printf("Device configuration data in flash invalid, reset to default values\r\n");
        memset(&devices_config, 0, sizeof(devices_config_t));
        devices_config.DEVICE_NUM = 0;
        devices_config.mode.mode = REMOTE_MODE;
        devices_config.mode.pos_set_mode = NONE_SETTING_MODE;
    } else {

		if((devices_config.mode.mode == 0xff) && (devices_config.mode.pos_set_mode == 0xff)){
			devices_config.mode.mode = REMOTE_MODE;
			devices_config.mode.pos_set_mode = NONE_SETTING_MODE;
		}
        co_printf("Device configuration loaded from flash successfully, device count: %d\r\n", devices_config.DEVICE_NUM);
    }
}

/**
 * @brief 获取当前设备数量
 * @return 设备数量
 */
uint8_t devices_config_get_device_count(void)
{
    return devices_config.DEVICE_NUM;
}

/**
 * @brief 根据设备名称查找设备索引
 * @param device_name 设备名称
 * @param name_len 设备名称长度
 * @return 设备索引，如果未找到返回0xFF
 */
uint8_t devices_config_find_device_index(const uint8_t *device_name, uint16_t name_len)
{
    if (device_name == NULL || name_len == 0) {
        return 0xFF;
    }
    
    for (uint8_t i = 0; i < devices_config.DEVICE_NUM; i++) {
        if (strlen((char*)devices_config.offset_point_config[i].dev_name) == name_len &&
            memcmp(devices_config.offset_point_config[i].dev_name, device_name, name_len) == 0) {
            return i;
        }
    }
    
    return 0xFF;
}

/**
 * @brief 设置当前连接的设备名称
 * @param device_name 设备名称
 * @param name_len 设备名称长度
 */
void devices_config_set_current_device_name(const uint8_t *device_name, uint16_t name_len)
{
    if (device_name == NULL || name_len == 0 || name_len > 47) {
        co_printf("Set current device name parameter invalid\r\n");
        return;
    }
    
    // 直接设置全局设备名称
    memset(current_device_name, 0, sizeof(current_device_name));
    memcpy(current_device_name, device_name, name_len);
    current_device_name[name_len] = '\0';  // 确保字符串结束
    
    co_printf("Current device name set to: %s\r\n", current_device_name);
}